public BTreeNode(BTreeNode _parentNode, BTreeNodePrecondition _precondition = null)
{
m_ChildCount = 0;
m_ParentNode = _parentNode;
m_NodePrecondition = _precondition;
m_IsAcitonNode = false;
}
public BTreeNode SetNodePrecondition(BTreeNodePrecondition _NodePrecondition)
{
if (m_NodePrecondition != _NodePrecondition)
{
m_NodePrecondition = _NodePrecondition;
}
return(this);
}
private static BTreeNodePrecondition CreatePrecondition(ref BTreeNodePrecondition[] _nodePreconditions, PreconditionConfig[] _condConfigs, int _index)
{
int[] _childIndexs = _condConfigs[_index].m_ChildIndexs;
//int _parentIndex = _condConfigs[_index].m_ParentIndex;
if (_childIndexs != null && _childIndexs.Length != 0)
{
for (int i = 0; i < _childIndexs.Length; i++)
{
if (_nodePreconditions[_childIndexs[i]] == null)
{
_nodePreconditions[_childIndexs[i]] = CreatePrecondition(ref _nodePreconditions, _condConfigs, _childIndexs[i]);
}
}
}
BTreeNodePrecondition _precondition = null;
if (_childIndexs != null && _childIndexs.Length > 0)
{
PreconditionType type = (PreconditionType)_condConfigs[_index].m_Type;
BTreeNodePrecondition[] _childNodePreconditions = new BTreeNodePrecondition[_childIndexs.Length];
for (int i = 0; i < _childIndexs.Length; i++)
{
_childNodePreconditions[i] = _nodePreconditions[_childIndexs[i]];
}
switch (type)
{
case PreconditionType.And:
_precondition = new BTreeNodePreconditionAND(_childNodePreconditions);
break;
case PreconditionType.Or:
_precondition = new BTreeNodePreconditionOR(_childNodePreconditions);
break;
case PreconditionType.Not:
_precondition = new BTreeNodePreconditionNOT(_childNodePreconditions[0]);
break;
default:
break;
}
}
else
{
string typeName = _condConfigs[_index].m_PreconditionName;
if (PreconditionTypeDic.ContainsKey(typeName))
{
Type type = PreconditionTypeDic[typeName];
_precondition = (BTreeNodePrecondition)type.GetConstructor(new Type[] { }).Invoke(new object[] { });
}
}
return(_precondition);
}
private static BTreeNodePrecondition CreatePreconditionFromConfig(TreeNodeConfig _nodeConfig)
{
PreconditionConfig[] _condConfigs = _nodeConfig.m_Preconditions;
BTreeNodePrecondition[] _nodePreconditions = new BTreeNodePrecondition[_condConfigs.Length];
for (int i = 0; i < _nodePreconditions.Length; i++)
{
_nodePreconditions[i] = null;
}
for (int i = 0; i < _nodePreconditions.Length; i++)
{
if (_nodePreconditions[i] == null)
{
_nodePreconditions[i] = CreatePrecondition(ref _nodePreconditions, _condConfigs, i);
}
}
return(_nodePreconditions[0]);
}
private static void GetPreconditionConfigFromBtreeNode(BTreeNodePrecondition _precondition, ref PreconditionConfig[] _preconditionList, ref int _index, int _parentIndex = -1)
{
_preconditionList[_index] = new PreconditionConfig();
_preconditionList[_index].m_ParentIndex = _parentIndex;
Type type = _precondition.GetType();
_preconditionList[_index].m_PreconditionName = type.Name.Split('`')[0];
if (type.Equals(typeof(BTreeNodePreconditionAND)))
{
_preconditionList[_index].m_Type = (int)PreconditionType.And;
BTreeNodePrecondition[] _childPreconditon = ((BTreeNodePreconditionAND)_precondition).GetChildPrecondition();
_preconditionList[_index].m_ChildIndexs = new int[_childPreconditon.Length];
int parentIndex = _index;
for (int i = 0; i < _childPreconditon.Length; i++)
{
_index = _index + 1;
_preconditionList[parentIndex].m_ChildIndexs[i] = _index;
GetPreconditionConfigFromBtreeNode(_childPreconditon[i], ref _preconditionList, ref _index, parentIndex);
}
}
else if (type.Equals(typeof(BTreeNodePreconditionOR)))
{
_preconditionList[_index].m_Type = (int)PreconditionType.Or;
BTreeNodePrecondition[] _childPreconditon = ((BTreeNodePreconditionOR)_precondition).GetChildPrecondition();
_preconditionList[_index].m_ChildIndexs = new int[_childPreconditon.Length];
int parentIndex = _index;
for (int i = 0; i < _childPreconditon.Length; i++)
{
_index = _index + 1;
_preconditionList[parentIndex].m_ChildIndexs[i] = _index;
GetPreconditionConfigFromBtreeNode(_childPreconditon[i], ref _preconditionList, ref _index, parentIndex);
}
}
else if (type.Equals(typeof(BTreeNodePreconditionNOT)))
{
_preconditionList[_index].m_Type = (int)PreconditionType.Not;
BTreeNodePrecondition _childPreconditon = ((BTreeNodePreconditionNOT)_precondition).GetChildPrecondition();
_preconditionList[_index].m_ChildIndexs = new int[1];
_preconditionList[_index].m_ChildIndexs[0] = _index + 1;
int parentIndex = _index;
_index = _index + 1;
GetPreconditionConfigFromBtreeNode(_childPreconditon, ref _preconditionList, ref _index, parentIndex);
}
}
private static int GetBTreeChildPreconditionNum(BTreeNodePrecondition _precondition)
{
if (_precondition == null)
{
return(0);
}
int _count = 0;
Type type = _precondition.GetType();
if (type.Equals(typeof(BTreeNodePreconditionAND)))
{
_count += ((BTreeNodePreconditionAND)_precondition).GetChildPreconditionCount();
BTreeNodePrecondition[] _chlidList = ((BTreeNodePreconditionAND)_precondition).GetChildPrecondition();
if (_chlidList != null)
{
for (int i = 0; i < _chlidList.Length; i++)
{
_count += GetBTreeChildPreconditionNum(_chlidList[i]);
}
}
}
else if (type.Equals(typeof(BTreeNodePreconditionOR)))
{
_count += ((BTreeNodePreconditionOR)_precondition).GetChildPreconditionCount();
BTreeNodePrecondition[] _chlidList = ((BTreeNodePreconditionOR)_precondition).GetChildPrecondition();
if (_chlidList != null)
{
for (int i = 0; i < _chlidList.Length; i++)
{
_count += GetBTreeChildPreconditionNum(_chlidList[i]);
}
}
}
else if (type.Equals(typeof(BTreeNodePreconditionNOT)))
{
_count += 1;
_count += GetBTreeChildPreconditionNum(((BTreeNodePreconditionNOT
)_precondition).GetChildPrecondition());
}
return(_count);
}
public BTreeNodeParallel(BTreeNode _parentNode, BTreeNodePrecondition _precondition = null)
: base(_parentNode, _precondition)
{
}
