public void Dispose()
{
Abort();
Parent = null;
mRoot = null;
Runner = null;
}
public void UnregisterNode(long nodeID)
{
IBTNode node = null;
_treeNodes.TryGetAndRemove(nodeID, out node);
if (node != null)
{
node.NodeErrorEvent -= OnNodeErrorMessageHandler;
this.ResetEvent -= node.Reset;
IBTNode[] allNodes = _treeNodes.GetValues();
for (int i = 0; i < allNodes.Length; i++)
{
IBTComposite cNode = allNodes[i] as IBTComposite;
if (cNode != null)
{
bool removed = cNode.RemoveChildNode(node);
if (removed)
{
return;
}
}
}
}
}
public override void Execute()
{
if (curIndex >= mNodeList.Count)
{
mStatus = BTStatus.Success;
mTree.SetCurNode(mParent);
return;
}
IBTNode node = mNodeList[curIndex];
// If the node is Running, means haven't been started yet.
// If node has already been set, this part won't run until the node returns success.
if (node.Status == BTStatus.Running)
{
mTree.SetCurNode(node);
}
// If the node succeded, the node would have set this sequence to curNode in BehaviourTree.
// When it comes around,
else if (node.Status == BTStatus.Success)
{
curIndex++;
}
// If the node has failed, exit sequence.
else if (node.Status == BTStatus.Failure)
{
mStatus = BTStatus.Failure;
mTree.SetCurNode(mParent);
}
}
public bool RemoveChildNode(IBTNode node)
{
if (node == null)
{
return(false);
}
return(_nodes.Remove(node));
}
private IBTCondition CreateCondition(XmlNode node)
{
string conditionClassName = node.Attributes["name"].Value;
//Debug.Log("Creating condition " + conditionClassName);
IBTNode btNode = (IBTNode)CreateReflectionObject(conditionClassName);
return((IBTCondition)btNode);
}
public bool RemoveChildNode(IBTNode node)
{
if (_childNode != null && _childNode == node)
{
_childNode = null;
return(true);
}
return(false);
}
public void AddChildNode(params IBTNode[] nodes)
{
if (nodes != null && nodes.Length == 0)
{
return;
}
if (nodes[0] == null || nodes[0] == this)
{
return;
}
_childNode = nodes[0];
}
public void RegisterNode(IBTNode node)
{
if (node != null)
{
ResetEvent -= node.Reset;
ResetEvent += node.Reset;
node.NodeErrorEvent -= OnNodeErrorMessageHandler;
node.NodeErrorEvent += OnNodeErrorMessageHandler;
_treeNodes[node.UniqueID] = node;
}
}
void EditorAccess(IBTNode node)
{
mEditorAccessed.Add(node);
var p = this;
while (p != null)
{
p.mEditorAccessedDeep.Add(node);
if (p == mRoot)
{
break;
}
p = p.Parent;
}
}
private IBTNode CreateBtNode(XmlNode node)
{
IBTNode btNode = null;
switch (node.Name)
{
case "action":
btNode = CreateAction(node);
break;
case "condition":
btNode = CreateCondition(node);
break;
}
return(btNode);
}
void Awake()
{
m_Animator = GetComponent <Animator>();
m_Transform = gameObject.transform;
m_RigidBody = GetComponent <Rigidbody2D>();
m_State = new State();
m_SingleCollider.OnTriggerEnter = EnteredCollision;
m_SingleCollider.OnTriggerExit = ExitCollision;
m_Context = CreateClassContext();
m_BehaviourTree = GetNode();
m_AnimationState = new AnimationState(m_Animator);
m_InputState = new InputState();
}
public void Start()
{
//m_Animator = GetComponent<Animator>();
m_Transform = transform;
m_RigidBody = GetComponent <Rigidbody2D>();
m_HitBoxCollider.OnTriggerEnter = PlayerEnteredAttackRange;
m_FrontCollider.OnTriggerEnter = PlayerEnteredAttackRange;
m_FrontCollider.OnTriggerExit = PlayerExitedAttackRange;
m_NextWaypoint = m_StartWaypoint;
m_BehaviourTree = GetNode();
m_State = new State();
m_Context = CreateClassContext();
}
public void Clear()
{
Stop();
ResetEvent?.Invoke(this, null);
IBTNode[] allNodes = _treeNodes.GetValues();
for (int i = 0; i < allNodes.Length; i++)
{
IBTNode cNode = allNodes[i];
if (cNode != null)
{
cNode.NodeErrorEvent -= OnNodeErrorMessageHandler;
this.ResetEvent -= cNode.Reset;
}
}
_treeNodes.Clear();
}
private IBTNode CreateTreeFromXML(XmlNodeList xmlChildren)
{
IBTSequencer btNode = new BTSequencer();
foreach (XmlNode node in xmlChildren)
{
if (node.ChildNodes.Count > 0)
{
IBTNode childrenNode = CreateTreeFromXML(node.ChildNodes);
btNode.AppendNode(CreateBtNode(node, childrenNode));
}
else
{
btNode.AppendNode(CreateBtNode(node));
}
}
return(btNode);
}
private IBTNode CreateBtNode(XmlNode node, IBTNode children)
{
IBTNode btNode = null;
switch (node.Name)
{
case "sequence":
btNode = CreateSequence(node).AppendNode(children);
break;
case "inverter":
btNode = CreateInverter(node).SetNode(children);
break;
case "positiveSequence":
btNode = CreatePositiveSequence(node).AppendNode(children);
break;
}
return(btNode);
}
public IBTPositiveSequencer AppendNode(IBTNode node)
{
this.childNodes.Add(node);
return(this);
}
public IBTInvertor SetNode(IBTNode node)
{
childNode = node;
return(this);
}
public void SetCurNode(IBTNode _newCurNode)
{
mCurNode = _newCurNode;
}
public IBTSelector AppendNode(IBTNode node)
{
this.childNodes.Add(node);
return(this);
}
public void SetBehaviuor(IBTNode root)
{
Abort();
mRoot = root;
IsComplate = Runner != null && mRoot == null;
}
public bool RemoveChildNode(IBTNode node)
{
return(_rootSelector.RemoveChildNode(node));
}
public BTRoot(IBTNode node)
{
this.node = node;
}
private void ResetTree()
{
mCurNode = mRootNode;
mCurNode.ResetNode();
}
public void SetParent(IBTNode _mParent)
{
mParent = _mParent;
}
public BehaviourTree(IBTNode _rootNode)
{
mRootNode = _rootNode;
mRootNode.SetTree(this);
ResetTree();
}
