/// <summary>
/// 更新NodeDefine的内容
/// </summary>
/// <param name="nodeDefine"></param>
public void UpdateNodeDefine(NodeDefine nodeDefine)
{
if (nodeDefine == null)
{
return;
}
if (nodeDefine == this)
{
return;
}
//改名
if (m_ClassType != nodeDefine.ClassType)
{
MainForm.Instance.BehaviorTreeData.UpdateClassType(m_ClassType, nodeDefine.ClassType);
ContentUserControl.Instance.ClearAllSelected();
}
m_ClassType = nodeDefine.ClassType;
m_Label = nodeDefine.Label;
m_Category = nodeDefine.Category;
m_NodeType = nodeDefine.NodeType;
m_Describe = nodeDefine.Describe;
m_CheckField = nodeDefine.CheckField;
m_Fields.Clear();
m_Fields.AddRange(nodeDefine.Fields);
}
/// <summary>
/// 添加节点类
/// </summary>
/// <param name="nodeDefine"></param>
public bool AddClass(NodeDefine nodeDefine)
{
if (nodeDefine == null)
{
return(false);
}
for (int i = 0; i < m_Nodes.Count; i++)
{
NodeDefine tmp = m_Nodes[i];
if (tmp.ClassType == nodeDefine.ClassType)
{
MainForm.Instance.ShowMessage(string.Format("已存在{0},请换一个类名", nodeDefine.ClassType), "警告");
return(false);
}
}
m_Nodes.Add(nodeDefine);
m_Nodes.Sort(delegate(NodeDefine a, NodeDefine b)
{
return(a.NodeType.CompareTo(b.NodeType));
});
return(true);
}
private void 除ToolStripMenuItem_Click(object sender, EventArgs e)
{
if (treeView1.SelectedNode == null)
{
return;
}
if (treeView1.SelectedNode.Tag == null)
{
return;
}
if (!(treeView1.SelectedNode.Tag is NodeItem))
{
return;
}
NodeItem nodeItem = treeView1.SelectedNode.Tag as NodeItem;
NodeDefine nodeDefine = nodeItem.NodeDefine;
if (MessageBox.Show(string.Format("是否删除节点{0}？", nodeDefine.ClassType), "提示", MessageBoxButtons.OKCancel) == DialogResult.OK)
{
m_Nodes.Remove(nodeDefine);
m_NodeTreeViewManager.RemoveNodeDefine(nodeDefine);
}
}
private void 退出ToolStripMenuItem_Click(object sender, EventArgs e)
{
NodeDefine nodeDefine = new NodeDefine();
InputValueDialogForm testForm = new InputValueDialogForm("编辑", nodeDefine);
testForm.ShowDialog();
}
private void 编辑类ToolStripMenuItem_Click(object sender, EventArgs e)
{
if (treeView1.SelectedNode == null)
{
return;
}
if (treeView1.SelectedNode.Tag == null)
{
return;
}
if (!(treeView1.SelectedNode.Tag is NodeItem))
{
return;
}
NodeItem nodeItem = treeView1.SelectedNode.Tag as NodeItem;
NodeDefine nodeDefine = nodeItem.NodeDefine;
EditNodeDefineForm editClassForm = new EditNodeDefineForm(this, nodeDefine, delegate()
{
nodeItem = m_NodeTreeViewManager.BindNodeDefine(nodeDefine);
treeView1.SelectedNode = nodeItem.TreeNode;
});
editClassForm.ShowDialog();
}
private void CopyClass()
{
if (treeView1.SelectedNode == null)
{
return;
}
if (treeView1.SelectedNode.Tag == null)
{
return;
}
if (!(treeView1.SelectedNode.Tag is NodeItem))
{
return;
}
NodeItem nodeItem = treeView1.SelectedNode.Tag as NodeItem;
NodeDefine nodeDefine = nodeItem.NodeDefine;
NodeDefineListContent content = new NodeDefineListContent();
content.DataList.Add(nodeDefine);
if (content.DataList.Count > 0)
{
Clipboard.SetText(XmlUtility.ObjectToString(content));
}
MainForm.Instance.ShowInfo("您复制了" + content.DataList.Count.ToString() + "个节点类！！！");
}
private void PasteClass()
{
try
{
NodeDefineListContent content = XmlUtility.StringToObject <NodeDefineListContent>(Clipboard.GetText());
NodeDefine nodeDefine = null;
for (int i = 0; i < content.DataList.Count; i++)
{
nodeDefine = content.DataList[i];
string classType = nodeDefine.ClassType;
do
{
classType += "_New";
}while (m_Nodes.ExistClassType(classType));
nodeDefine.ClassType = classType;
m_Nodes.AddClass(nodeDefine);
}
m_NodeTreeViewManager.BindNodeDefine(nodeDefine);
MainForm.Instance.ShowInfo("您粘贴了" + content.DataList.Count + "个节点类！！！");
}
catch (Exception ex)
{
MainForm.Instance.ShowInfo("无法进行粘贴，错误信息：" + ex.Message);
MainForm.Instance.ShowMessage("无法进行粘贴，错误信息：" + ex.Message, "警告");
}
}
/// <summary>
/// 检验节点类ClassType
/// </summary>
/// <returns></returns>
public VerifyInfo VerifyClassType()
{
//校验ClassType是否为空
for (int i = 0; i < m_Nodes.Count; i++)
{
NodeDefine nodeDefine = m_Nodes[i];
if (string.IsNullOrEmpty(nodeDefine.ClassType))
{
return(new VerifyInfo("存在空的ClassType"));
}
}
//检验ClassType是否相同
for (int i = 0; i < m_Nodes.Count; i++)
{
NodeDefine classType_i = m_Nodes[i];
if (classType_i != null)
{
for (int ii = i + 1; ii < m_Nodes.Count; ii++)
{
NodeDefine classtType_ii = m_Nodes[ii];
if (classType_i.ClassType == classtType_ii.ClassType)
{
return(new VerifyInfo(string.Format("行为树存在相同ClassType:{0}", classType_i.ClassType)));
}
}
}
}
return(VerifyInfo.DefaultVerifyInfo);
}
public bool RemoveNodeDefine(NodeDefine nodeDefine)
{
NodeItem nodeItem = FindNodeItem(nodeDefine);
if (nodeItem != null)
{
nodeItem.TreeNode.Remove();
}
if (nodeItem.CategoryItem != null)
{
TreeNode treeNode = nodeItem.CategoryItem.TreeNode;
while (treeNode.Tag is CategoryItem)
{
TreeNode parentNode = treeNode.Parent;
if (treeNode.Nodes.Count == 0)
{
treeNode.Remove();
treeNode = parentNode;
}
else
{
break;
}
}
}
return(false);
}
/// <summary>
/// 删除节点类
/// </summary>
/// <param name="nodeDefine">节点类对象</param>
/// <returns></returns>
public bool Remove(NodeDefine nodeDefine)
{
if (nodeDefine == null)
{
return(false);
}
return(m_Nodes.Remove(nodeDefine));
}
/// <summary>
/// 移除未定义的枚举字段
/// </summary>
public void RemoveUnDefineEnumField()
{
for (int i = 0; i < m_Nodes.Count; i++)
{
NodeDefine nodeDefine = m_Nodes[i];
nodeDefine.RemoveUnDefineEnumField();
}
}
public EditNodeDefineForm(NodeTemplateForm classForm, NodeDefine nodeDefine, Action editCallback)
{
m_ClassForm = classForm;
m_NodeDefine = nodeDefine;
m_Content = XmlUtility.ObjectToString(m_NodeDefine);
m_EditNodeDefine = XmlUtility.StringToObject <NodeDefine>(m_Content);
m_EditCallback = editCallback;
InitializeComponent();
}
public void BindNodeTemplate()
{
for (int i = 0; i < m_NodeTemplate.Nodes.Count; i++)
{
NodeDefine nodeDefine = m_NodeTemplate.Nodes[i];
BindNodeDefine(nodeDefine);
}
m_TreeView.ExpandAll();
m_TreeView.SelectedNode = m_TreeView.Nodes[0];
m_TreeView.Nodes[0].EnsureVisible();
}
private void treeView1_MouseDown(object sender, MouseEventArgs e)
{
if (treeView1.SelectedNode == null)
{
return;
}
for (int i = 0; i < contextMenuStrip1.Items.Count; i++)
{
contextMenuStrip1.Items[i].Visible = false;
}
if (treeView1.SelectedNode.Tag is NodeTypeItem || treeView1.SelectedNode.Tag is CategoryItem)
{
contextMenuStrip1.Items[0].Visible = true;
contextMenuStrip1.Items[3].Visible = true;
}
else if (treeView1.SelectedNode.Tag is NodeItem)
{
contextMenuStrip1.Items[1].Visible = true;
contextMenuStrip1.Items[2].Visible = true;
}
if (e.Clicks == 2)
{
if (treeView1.SelectedNode == null)
{
return;
}
if (treeView1.SelectedNode.Tag == null)
{
return;
}
if (!(treeView1.SelectedNode.Tag is NodeItem))
{
return;
}
NodeItem nodeItem = treeView1.SelectedNode.Tag as NodeItem;
NodeDefine nodeDefine = nodeItem.NodeDefine;
EditNodeDefineForm editClassForm = new EditNodeDefineForm(this, nodeDefine, delegate()
{
nodeItem = m_NodeTreeViewManager.BindNodeDefine(nodeDefine);
treeView1.SelectedNode = nodeItem.TreeNode;
});
editClassForm.ShowDialog();
}
}
public NodeItem FindNodeItem(NodeDefine nodeDefine)
{
for (int i = 0; i < m_TreeView.Nodes.Count; i++)
{
TreeNode treeNode = m_TreeView.Nodes[i];
NodeItem nodeItem = FindNodeItem(treeNode, nodeDefine);
if (nodeItem != null)
{
return(nodeItem);
}
}
return(null);
}
/// <summary>
/// 移除未定义的节点
/// </summary>
public bool RemoveUnDefineNode()
{
bool remove = false;
for (int i = m_Nodes.Count - 1; i >= 0; i--)
{
NodeDesigner node = m_Nodes[i];
NodeDefine nodeDefine = MainForm.Instance.NodeTemplate.FindNode(node.ClassType);
if (nodeDefine == null)
{
RemoveNode(node);
remove = true;
}
}
return(remove);
}
//刷新ListView
private void BindField(NodeDefine nodeDefine)
{
if (nodeDefine == null)
{
return;
}
listViewFields.Items.Clear();
foreach (NodeField field in nodeDefine.Fields)
{
ListViewItem listViewItem = listViewFields.Items.Add(field.FieldName);
listViewItem.Tag = field;
listViewItem.SubItems.Add(field.Label);
listViewItem.SubItems.Add(EditorUtility.GetFieldTypeName(field.FieldType));
listViewItem.SubItems.Add(field.DefaultValue != null ? field.DefaultValue.ToString() : string.Empty);
listViewItem.SubItems.Add(field.Describe);
}
}
/// <summary>
/// 获取指定类型所有组合节点类
/// </summary>
/// <param name="nodeType">节点类型</param>
/// <returns></returns>
public List <NodeDefine> GetNodeDefines(NodeType nodeType)
{
List <NodeDefine> nodeList = new List <NodeDefine>();
for (int i = 0; i < m_Nodes.Count; i++)
{
NodeDefine nodeDefine = m_Nodes[i];
if (nodeDefine == null)
{
continue;
}
if (nodeDefine.NodeType == nodeType)
{
nodeList.Add(nodeDefine);
}
}
return(nodeList);
}
/// <summary>
/// 通过ClassType查找节点
/// </summary>
/// <param name="classType"></param>
/// <returns></returns>
public NodeDefine FindNode(string classType)
{
if (string.IsNullOrEmpty(classType))
{
return(null);
}
for (int i = 0; i < m_Nodes.Count; i++)
{
NodeDefine nodeDefine = m_Nodes[i];
if (nodeDefine != null && nodeDefine.ClassType == classType)
{
return(nodeDefine);
}
}
return(null);
}
/// <summary>
/// 校节点类数据
/// </summary>
/// <returns></returns>
public VerifyInfo VerifyNodeTemplate()
{
VerifyInfo verifyClassType = VerifyClassType();
if (verifyClassType.HasError)
{
return(verifyClassType);
}
for (int i = 0; i < m_Nodes.Count; i++)
{
NodeDefine nodeDefine = m_Nodes[i];
VerifyInfo verifyNodeDefine = nodeDefine.VerifyNodeDefine();
if (verifyNodeDefine.HasError)
{
return(verifyNodeDefine);
}
}
return(VerifyInfo.DefaultVerifyInfo);
}
public bool ExistClassType(string classType)
{
if (string.IsNullOrEmpty(classType))
{
throw new System.Exception("NodeTemplate.ExistClassType() classType类型为空");
}
for (int i = 0; i < m_Nodes.Count; i++)
{
NodeDefine nodeDefine = m_Nodes[i];
if (nodeDefine == null)
{
continue;
}
if (nodeDefine.ClassType == classType)
{
return(true);
}
}
return(false);
}
private NodeItem FindNodeItem(TreeNode treeNode, NodeDefine nodeDefine)
{
if (treeNode.Tag is NodeItem)
{
NodeItem nodeItem = treeNode.Tag as NodeItem;
if (nodeItem.NodeDefine.ClassType == nodeDefine.ClassType || nodeItem.NodeDefine == nodeDefine)
{
return(nodeItem);
}
}
for (int i = 0; i < treeNode.Nodes.Count; i++)
{
TreeNode tempTreeNode = treeNode.Nodes[i];
NodeItem nodeItem = FindNodeItem(tempTreeNode, nodeDefine);
if (nodeItem != null)
{
return(nodeItem);
}
}
return(null);
}
/// <summary>
/// 修正数据
/// </summary>
public bool AjustData()
{
bool ajust = false;
for (int i = 0; i < m_Nodes.Count; i++)
{
NodeDesigner node = m_Nodes[i];
NodeDefine nodeDefine = MainForm.Instance.NodeTemplate.FindNode(node.ClassType);
//修正节点标签
if (node.Label != nodeDefine.Label)
{
node.Label = nodeDefine.Label;
ajust = true;
}
//移除模板中没有的字段
for (int ii = node.Fields.Count - 1; ii >= 0; ii--)
{
FieldDesigner field = node.Fields[ii];
if (!nodeDefine.ExistFieldName(field.FieldName))
{
ajust = true;
node.Fields.RemoveAt(ii);
}
}
//修正类型不匹配的(节点字段和模板字段类型不匹配)
for (int ii = 0; ii < node.Fields.Count; ii++)
{
FieldDesigner field = node.Fields[ii];
NodeField nodeField = nodeDefine.FindField(field.FieldName);
if (field.FieldType != nodeField.FieldType)
{
//重新给默认值
node.Fields[ii] = EditorUtility.CreateFieldByNodeField(nodeField);
ajust = true;
}
}
//添加不存的字段
for (int ii = nodeDefine.Fields.Count - 1; ii >= 0; ii--)
{
NodeField nodeField = nodeDefine.Fields[ii];
FieldDesigner field = node.FindFieldByName(nodeField.FieldName);
//不存在的字段要添加
if (field == null)
{
FieldDesigner newField = EditorUtility.CreateFieldByNodeField(nodeField);
node.AddField(newField);
ajust = true;
}
}
//排序字段（要和模板中一致）
for (int ii = 0; ii < nodeDefine.Fields.Count; ii++)
{
NodeField nodeField = nodeDefine.Fields[ii];
int index = node.GetFieldIndex(nodeField.FieldName);
if (index != ii)
{
//交换
FieldDesigner tempField_ii = node.Fields[ii];
node.Fields[ii] = node.Fields[index];
node.Fields[index] = tempField_ii;
ajust = true;
}
}
//修正Label
for (int ii = 0; ii < node.Fields.Count; ii++)
{
FieldDesigner field = node.Fields[ii];
NodeField nodeField = nodeDefine.Fields[ii];
if (field.Label != nodeField.Label)
{
field.Label = nodeField.Label;
ajust = true;
}
}
}
return(ajust);
}
/// <summary>
/// 添加行为树
/// </summary>
private void AddBehaviorTree()
{
if (WorkSpaceData == null)
{
ShowMessage("当前没有工作空间，请新建或者打开工作空间！");
return;
}
if (BehaviorTreeData == null)
{
return;
}
string group = string.Empty;
if (treeView1.SelectedNode != null)
{
if (treeView1.SelectedNode.Tag is GroupItem)
{
GroupItem groupItem = treeView1.SelectedNode.Tag as GroupItem;
group = groupItem.Group.GroupName;
}
else if (treeView1.SelectedNode.Tag is BehaviorTreeItem)
{
BehaviorTreeItem behaviorTreeItem = treeView1.SelectedNode.Tag as BehaviorTreeItem;
if (behaviorTreeItem.GroupItem != null)
{
group = behaviorTreeItem.GroupItem.Group.GroupName;
}
}
}
BehaviorTreeDesigner behaviorTree = new BehaviorTreeDesigner();
behaviorTree.GroupName = group;
string behaviorTreeID = "New_" + DateTime.Now.Ticks;
do
{
behaviorTreeID = "New_" + DateTime.Now.Ticks;
} while (BehaviorTreeData.ExistBehaviorTree(behaviorTreeID));
behaviorTree.ID = behaviorTreeID;
//创建开始节点
NodeDesigner startNode = null;
NodeDefine nodeDefine = NodeTemplate.FindNode("Sequence");
if (nodeDefine != null)
{
Rect rect = new Rect(EditorUtility.Center.x, EditorUtility.Center.y, EditorUtility.NodeWidth,
EditorUtility.NodeHeight);
startNode = new NodeDesigner(nodeDefine.Label, nodeDefine.ClassType, rect);
startNode.ID = behaviorTree.GenNodeID();
startNode.StartNode = true;
startNode.NodeType = nodeDefine.NodeType;
//创建字段
for (int i = 0; i < nodeDefine.Fields.Count; i++)
{
NodeField nodeField = nodeDefine.Fields[i];
FieldDesigner field = EditorUtility.CreateFieldByNodeField(nodeField);
if (field == null)
{
continue;
}
startNode.Fields.Add(field);
}
behaviorTree.AddNode(startNode);
}
//创建空操作节点
NodeDefine noopDefine = NodeTemplate.FindNode("Noop");
if (startNode != null && noopDefine != null)
{
Rect rect = new Rect(EditorUtility.Center.x + 250, EditorUtility.Center.y, EditorUtility.NodeWidth,
EditorUtility.NodeHeight);
NodeDesigner noopNode = new NodeDesigner(noopDefine.Label, noopDefine.ClassType, rect);
noopNode.ID = behaviorTree.GenNodeID();
noopNode.NodeType = noopDefine.NodeType;
noopNode.Describe = noopDefine.Describe;
behaviorTree.AddNode(noopNode);
startNode.AddChildNode(noopNode);
}
TreeViewManager.AddBehaviorTree(behaviorTree);
}
public NodeItem BindNodeDefine(NodeDefine nodeDefine)
{
NodeTypeItem nodeTypeItem = GetNodeTypeItem(nodeDefine.NodeType);
if (nodeTypeItem == null)
{
return(null);
}
NodeItem nodeItem = FindNodeItem(nodeDefine);
//刷新
if (nodeItem != null)
{
if (nodeItem.OldNodeType == nodeDefine.NodeType && nodeItem.OldCategory == nodeDefine.Category)
{
nodeItem.TreeNode.Text = nodeDefine.ClassType + (string.IsNullOrEmpty(nodeDefine.Label) ? string.Empty : " (" + nodeDefine.Label + ")");
return(nodeItem);
}
else
{
nodeItem.TreeNode.Remove();
}
if (nodeItem.OldCategory != nodeDefine.Category)
{
CheckRemoveCategory(nodeItem.OldNodeType, nodeItem.OldCategory);
}
}
if (nodeItem == null)
{
nodeItem = new NodeItem();
}
if (string.IsNullOrEmpty(nodeDefine.Category))
{
TreeNode treeNode = nodeTypeItem.TreeNode.Nodes.Add(nodeDefine.ClassType + (string.IsNullOrEmpty(nodeDefine.Label) ? string.Empty : " (" + nodeDefine.Label + ")"));
treeNode.Tag = nodeItem;
nodeItem.TreeNode = treeNode;
nodeItem.CategoryItem = null;
nodeItem.NodeTypeItem = nodeTypeItem;
nodeItem.NodeDefine = nodeDefine;
nodeItem.OldCategory = nodeDefine.Category;
nodeItem.OldNodeType = nodeDefine.NodeType;
}
else
{
CategoryItem categoryItem = FindCategoryItem(nodeDefine.NodeType, nodeDefine.Category);
if (categoryItem == null)
{
categoryItem = BindCategory(nodeTypeItem.TreeNode, nodeDefine.Category);
}
TreeNode treeNode = categoryItem.TreeNode.Nodes.Add(nodeDefine.ClassType + (string.IsNullOrEmpty(nodeDefine.Label) ? string.Empty : " (" + nodeDefine.Label + ")"));
treeNode.Tag = nodeItem;
nodeItem.TreeNode = treeNode;
nodeItem.CategoryItem = categoryItem;
nodeItem.NodeTypeItem = nodeTypeItem;
nodeItem.NodeDefine = nodeDefine;
nodeItem.OldCategory = nodeDefine.Category;
nodeItem.OldNodeType = nodeDefine.NodeType;
}
return(nodeItem);
}
public void ResetNodes()
{
m_Nodes.Clear();
#region 组合节点
//并行节点
NodeDefine parallelNode = new NodeDefine();
parallelNode.ClassType = "Parallel";
parallelNode.Label = "并行节点";
parallelNode.NodeType = NodeType.Composite;
parallelNode.Describe = "Parallel节点在一般意义上是并行的执行其子节点，即“一边做A，一边做B”";
//成功条件
NodeField parallelNodeSuccessType = new NodeField()
{
FieldName = "SuccessType", FieldType = FieldType.EnumField, Describe = "成功条件"
};
EnumDefaultValue parallelNodeSuccessEnumDefaultValue = parallelNodeSuccessType.DefaultValue as EnumDefaultValue;
parallelNodeSuccessEnumDefaultValue.EnumType = "SUCCESS_POLICY";
parallelNodeSuccessEnumDefaultValue.DefaultValue = "SUCCEED_ON_ALL";
parallelNodeSuccessType.Label = "成功条件";
parallelNode.AddField(parallelNodeSuccessType);
//失败条件
NodeField parallelNodeFailType = new NodeField()
{
FieldName = "FailType", FieldType = FieldType.EnumField, Describe = "失败条件"
};
EnumDefaultValue parallelNodeFailTypeEnumDefaultValue = parallelNodeFailType.DefaultValue as EnumDefaultValue;
parallelNodeFailTypeEnumDefaultValue.EnumType = "FAILURE_POLICY";
parallelNodeFailTypeEnumDefaultValue.DefaultValue = "FAIL_ON_ONE";
parallelNodeFailType.Label = "失败条件";
parallelNode.AddField(parallelNodeFailType);
AddClass(parallelNode);
//顺序节点
NodeDefine sequenceNode = new NodeDefine();
sequenceNode.ClassType = "Sequence";
sequenceNode.Label = "顺序节点";
sequenceNode.NodeType = NodeType.Composite;
sequenceNode.Describe = "Sequence节点以给定的顺序依次执行其子节点，直到所有子节点成功返回，该节点也返回成功。只要其中某个子节点失败，那么该节点也失败。";
AddClass(sequenceNode);
//选择节点
NodeDefine Selector = new NodeDefine();
Selector.ClassType = "Selector";
Selector.Label = "选择节点";
Selector.Category = "";
Selector.NodeType = NodeType.Composite;
Selector.Describe = "选择节点";
AddClass(Selector);
//ifelse
NodeDefine IfElse = new NodeDefine();
IfElse.ClassType = "IfElse";
IfElse.Label = "IfElse";
IfElse.NodeType = NodeType.Composite;
IfElse.Describe = "";
AddClass(IfElse);
//随机节点
NodeDefine Random = new NodeDefine();
Random.ClassType = "Random";
Random.Label = "随机节点";
Random.Category = "随机";
Random.NodeType = NodeType.Composite;
Random.Describe = "随机节点";
AddClass(Random);
//随机选择节点
NodeDefine RandomSelector = new NodeDefine();
RandomSelector.ClassType = "RandomSelector";
RandomSelector.Label = "随机选择";
RandomSelector.Category = "随机";
RandomSelector.NodeType = NodeType.Composite;
RandomSelector.Describe = "随机选择节点";
AddClass(RandomSelector);
//随机序列节点
NodeDefine RandomSequence = new NodeDefine();
RandomSequence.ClassType = "RandomSequence";
RandomSequence.Label = "随机序列";
RandomSequence.Category = "随机";
RandomSequence.NodeType = NodeType.Composite;
RandomSequence.Describe = "随机序列节点";
AddClass(RandomSequence);
//概率选择节点
NodeDefine SelectorProbability = new NodeDefine();
SelectorProbability.ClassType = "SelectorProbability";
SelectorProbability.Label = "概率选择节点";
SelectorProbability.Category = "";
SelectorProbability.NodeType = NodeType.Composite;
SelectorProbability.Describe = "概率选择节点";
SelectorProbability.AddField(new NodeField()
{
FieldName = "Priority", Label = "优先级", FieldType = FieldType.RepeatIntField, Describe = "", Show = true
});
AddClass(SelectorProbability);
#endregion
#region 装饰节点
//成功节点
NodeDefine Success = new NodeDefine();
Success.ClassType = "Success";
Success.Label = "成功节点";
Success.NodeType = NodeType.Decorator;
Success.Describe = "成功节点";
AddClass(Success);
//失败节点
NodeDefine Failure = new NodeDefine();
Failure.ClassType = "Failure";
Failure.Label = "失败节点";
Failure.NodeType = NodeType.Decorator;
Failure.Describe = "失败节点";
AddClass(Failure);
//帧数节点用于在指定的帧数内，持续调用其子节点
NodeDefine Frames = new NodeDefine();
Frames.ClassType = "Frames";
Frames.Label = "帧数节点";
Frames.NodeType = NodeType.Decorator;
Frames.CheckField = true;
NodeField FramesField = new NodeField()
{
FieldName = "Frames", Label = "持续帧数", FieldType = FieldType.IntField, Describe = "持续帧数", Show = true
};
(FramesField.DefaultValue as IntDefaultValue).DefaultValue = 1;
Frames.AddField(FramesField);
Frames.Describe = "帧数节点用于在指定的帧数内，持续调用其子节点";
AddClass(Frames);
//循环节点 -1无限循环
NodeDefine Loop = new NodeDefine();
Loop.ClassType = "Loop";
Loop.Label = "循环节点";
Loop.NodeType = NodeType.Decorator;
Loop.Describe = "循环节点 -1无限循环";
Loop.AddField(new NodeField()
{
FieldName = "LoopTimes", Label = "循环次数", FieldType = FieldType.IntField, Describe = "循环次数", Show = true
});
AddClass(Loop);
//取反节点
NodeDefine Not = new NodeDefine();
Not.ClassType = "Not";
Not.Label = "取反节点";
Not.NodeType = NodeType.Decorator;
Not.Describe = "取反节点";
AddClass(Not);
//指定时间内运行
NodeDefine Time = new NodeDefine();
Time.ClassType = "Time";
Time.Label = "时间";
Time.NodeType = NodeType.Decorator;
Time.Describe = "指定时间内运行";
NodeField TimeField = new NodeField()
{
FieldName = "Duration", Label = "持续时间(毫秒)", FieldType = FieldType.IntField, Describe = "持续时间(毫秒)", Show = true
};
(TimeField.DefaultValue as IntDefaultValue).DefaultValue = 1000;
Time.AddField(TimeField);
AddClass(Time);
//阻塞，直到子节点返回true
NodeDefine SuccessUntil = new NodeDefine();
SuccessUntil.ClassType = "SuccessUntil";
SuccessUntil.Label = "直到子节点返回True";
SuccessUntil.NodeType = NodeType.Decorator;
SuccessUntil.Describe = "直到子节点返回true";
AddClass(SuccessUntil);
#endregion
#region 条件节点
//比较节点
NodeDefine Compare = new NodeDefine();
Compare.ClassType = "Compare";
Compare.Label = "比较节点";
Compare.NodeType = NodeType.Condition;
Compare.Describe = "Compare节点对左右参数进行比较";
//左边参数类型
NodeField Compare_LeftType = new NodeField()
{
FieldName = "LeftType", FieldType = FieldType.EnumField, Describe = ""
};
(Compare_LeftType.DefaultValue as EnumDefaultValue).EnumType = "ParameterType";
Compare_LeftType.Label = "左参数类型";
Compare.AddField(Compare_LeftType);
//左边参数变量名
Compare.AddField(new NodeField()
{
FieldName = "LeftParameter", Label = "左参数名", FieldType = FieldType.StringField, Describe = "左边参数变量名", Show = true
});
//左边常数值
Compare.AddField(new NodeField()
{
FieldName = "LeftConstValue", Label = "左边常数值", FieldType = FieldType.IntField, Describe = "左边常数值，左边参数类型为Const生效"
});
//比较符号
NodeField Compare_Type = new NodeField()
{
FieldName = "CompareType", FieldType = FieldType.EnumField, Describe = "比较符号<、>、<=、>=、==、!=", Show = true
};
(Compare_Type.DefaultValue as EnumDefaultValue).EnumType = "CompareType";
Compare_Type.Label = "比较操作符";
Compare.AddField(Compare_Type);
//右边边参数类型
NodeField Compare_RightType = new NodeField()
{
FieldName = "RightType", FieldType = FieldType.EnumField, Describe = ""
};
(Compare_RightType.DefaultValue as EnumDefaultValue).EnumType = "ParameterType";
Compare_RightType.Label = "右参数类型";
Compare.AddField(Compare_RightType);
//右边参数变量名
Compare.AddField(new NodeField()
{
FieldName = "RightParameter", Label = "右参数名", FieldType = FieldType.StringField, Describe = "右边参数变量名", Show = true
});
AddClass(Compare);
//左边常数值
Compare.AddField(new NodeField()
{
FieldName = "RightConstValue", Label = "右边常数值", FieldType = FieldType.IntField, Describe = "右边常数值，右边参数类型为Const生效"
});
#endregion
#region 动作节点
//设置变量节点
NodeDefine SetVariable = new NodeDefine();
SetVariable.CheckField = false;
SetVariable.ClassType = "SetVariable";
SetVariable.Label = "设置变量节点";
SetVariable.NodeType = NodeType.Action;
SetVariable.Describe = "设置变量节点";
NodeField setVariableNodeField = new NodeField()
{
FieldName = "ParameterType", FieldType = FieldType.EnumField, Describe = ""
};
(setVariableNodeField.DefaultValue as EnumDefaultValue).EnumType = "ParameterType";
SetVariable.AddField(setVariableNodeField);
SetVariable.AddField(new NodeField()
{
FieldName = "ParameterName", Label = "变量名", FieldType = FieldType.StringField, Describe = "参数变量名", Show = true
});
SetVariable.AddField(new NodeField()
{
FieldName = "ParameterValue", Label = "变量值", FieldType = FieldType.IntField, Describe = "参数值", Show = true
});
AddClass(SetVariable);
//等待节点
NodeDefine Wait = new NodeDefine();
Wait.ClassType = "Wait";
Wait.Label = "等待节点";
Wait.NodeType = NodeType.Action;
Wait.Describe = "等待节点";
NodeField WaintField = new NodeField()
{
FieldName = "Millisecond", Label = "等待时间(毫秒)", FieldType = FieldType.IntField, Describe = "等待时间（毫秒）", Show = true
};
IntDefaultValue WaintFieldDefaultField = WaintField.DefaultValue as IntDefaultValue;
WaintFieldDefaultField.DefaultValue = 1000;
Wait.AddField(WaintField);
AddClass(Wait);
//空操作节点
NodeDefine Noop = new NodeDefine();
Noop.ClassType = "Noop";
Noop.Label = "空操作节点";
Noop.NodeType = NodeType.Action;
Noop.Describe = "空操作节点";
AddClass(Noop);
//输出Log节点
NodeDefine Log = new NodeDefine();
Log.ClassType = "Log";
Log.Label = "输出节点";
Log.NodeType = NodeType.Action;
Log.Describe = "输出log节点";
Log.AddField(new NodeField()
{
FieldName = "Content", Label = "输出内容", FieldType = FieldType.StringField, Describe = "输出的内容", Show = true
});
AddClass(Log);
#endregion
}
public void AddNodeDefine(NodeDefine nodeDefine)
{
m_NodeTreeViewManager.BindNodeDefine(nodeDefine);
MainForm.Instance.ShowInfo("成功添加:" + nodeDefine.ClassType + ",时间：" + DateTime.Now);
}
