public override BehaviorTreeStatus Execute()
{
if (Counter == Children.Count)
{
return(BehaviorTreeStatus.Success);
}
BehaviorTreeStatus status = Children[Counter].Execute();
if (status == BehaviorTreeStatus.Success)
{
if (Counter < Children.Count)
{
++Counter;
if (Counter == Children.Count)
{
return(BehaviorTreeStatus.Success);
}
}
}
else if (status == BehaviorTreeStatus.Failed)
{
Counter = 0;
return(BehaviorTreeStatus.Failed);
}
return(BehaviorTreeStatus.Ongoing);
}
public BehaviorTreeStatus Tick()
{
if (ResumeOngoingNodes)
{
if (OngoingNode != null)
{
BehaviorTreeStatus status = OngoingNode.Execute();
if (status == BehaviorTreeStatus.Failed || status == BehaviorTreeStatus.Success)
{
OngoingNode = null;
}
return(status);
}
else
{
BehaviorTreeStatus status = RootNode.Execute();
if (status == BehaviorTreeStatus.Ongoing)
{
OngoingNode = RootNode.GetNodeToExecute();
}
return(status);
}
}
else
{
Node nodeToExecute = RootNode.GetNodeToExecute();
LastExecutedName = nodeToExecute.Name;
return(nodeToExecute.Execute());
}
}
protected override void ProcessChildStatus(BehaviorTreeStatus status)
{
if (status == BehaviorTreeStatus.Failure)
{
status = BehaviorTreeStatus.Success;
}
SetExecutionStatus(status);
}
public override void Reevaluate()
{
BehaviorTreeStatus previousStatus = m_Child.ExecutionStatus;
m_Child.Reevaluate();
if (m_Child.ExecutionStatus != previousStatus)
{
ProcessChildStatus(m_Child.ExecutionStatus);
}
}
protected override void ProcessChildStatus(BehaviorTreeStatus status)
{
if (status == BehaviorTreeStatus.Success)
{
SetExecutionStatus(status);
}
else if (status == BehaviorTreeStatus.Failure)
{
m_Child.Restart();
}
}
protected override void ProcessChildStatus(BehaviorTreeStatus status)
{
if (status == BehaviorTreeStatus.Success || status == BehaviorTreeStatus.Inactive)
{
m_Child.Restart();
SetExecutionStatus(BehaviorTreeStatus.Running);
}
else //if (status == BehaviorTreeStatus.Failure)
{
SetExecutionStatus(status);
}
}
protected void SetExecutionStatus(BehaviorTreeStatus status)
{
if (m_ExecutionStatus != status)
{
m_ExecutionStatus = status;
if (StatusChangedEvent != null)
{
StatusChangedEvent(m_ExecutionStatus);
}
}
}
protected virtual void ProcessChildrenTick()
{
while (CanExecute())
{
BehaviorTreeStatus status = m_Children[m_CurrentChildIndex].Tick();
if (status == BehaviorTreeStatus.Running)
{
break;
}
else
{
OnChildExecuted(status);
}
}
}
public override BehaviorTreeStatus Execute()
{
BehaviorTreeStatus status = Child.Execute();
if (status == BehaviorTreeStatus.Success)
{
status = BehaviorTreeStatus.Failed;
}
else if (status == BehaviorTreeStatus.Failed)
{
status = BehaviorTreeStatus.Success;
}
return(status);
}
protected override void ProcessChildStatus(BehaviorTreeStatus status)
{
if (status == BehaviorTreeStatus.Success)
{
SetExecutionStatus(BehaviorTreeStatus.Failure);
}
else if (status == BehaviorTreeStatus.Failure)
{
SetExecutionStatus(BehaviorTreeStatus.Success);
}
else
{
SetExecutionStatus(BehaviorTreeStatus.Running);
}
}
protected override void ProcessChildrenTick()
{
while (CanExecute())
{
var child = m_Children[m_CurrentChildIndex];
// skip child already success
if (child.ExecutionStatus != BehaviorTreeStatus.Success)
{
BehaviorTreeStatus status = child.Tick();
OnChildExecuted(status);
}
m_CurrentChildIndex++;
}
m_CurrentChildIndex = 0;
}
protected virtual void ReevaluateChildren(int start, int end)
{
for (int index = 0; index < end; index++)
{
Node child = m_Children[index];
if (child.ExecutionStatus == BehaviorTreeStatus.Success || child.ExecutionStatus == BehaviorTreeStatus.Failure)
{
BehaviorTreeStatus previousStatus = child.ExecutionStatus;
child.Reevaluate();
if (child.ExecutionStatus != previousStatus)
{
OnConditionalAbort(index);
break;
}
}
}
}
protected override void OnChildExecuted(BehaviorTreeStatus status)
{
if (status == BehaviorTreeStatus.Failure)
{
///continue exe
m_CurrentChildIndex++;
if (m_CurrentChildIndex >= m_Children.Count)
{
SetExecutionStatus(status);
}
else
{
SetExecutionStatus(BehaviorTreeStatus.Running);
}
}
else
{
SetExecutionStatus(status);
}
}
protected override void OnChildExecuted(BehaviorTreeStatus status)
{
if (status == BehaviorTreeStatus.Success)
{
///continue exe
m_NumOfSuccessChildren++;
if (m_NumOfSuccessChildren >= m_Children.Count)
{
SetExecutionStatus(status);
}
else
{
SetExecutionStatus(BehaviorTreeStatus.Running);
}
}
else
{
SetExecutionStatus(status);
}
}
protected override void ProcessChildStatus(BehaviorTreeStatus status)
{
if (m_EndOnFailure && status == BehaviorTreeStatus.Failure)
{
m_ExecutionCount++;
SetExecutionStatus(BehaviorTreeStatus.Failure);
}
else if (status == BehaviorTreeStatus.Success || status == BehaviorTreeStatus.Failure)
{
m_ExecutionCount++;
if (m_RepeatTimes != RepeatForever && m_ExecutionCount >= m_RepeatTimes)
{
SetExecutionStatus(BehaviorTreeStatus.Success);
}
else
{
m_Child.Restart();
}
}
}
public override bool ConditionalAbort()
{
if (ExecutionStatus != BehaviorTreeStatus.Running &&
(m_AbortType == AbortType.LowerPriority || m_AbortType == AbortType.Both))
{
for (int index = 0; index < m_Children.Count; index++)
{
Node child = m_Children[index];
BehaviorTreeStatus previousStatus = child.ExecutionStatus;
child.Reevaluate();
if (child.ExecutionStatus != previousStatus)
{
OnConditionalAbort(index);
return(true);
}
}
}
return(false);
}
protected abstract void ProcessChildStatus(BehaviorTreeStatus status);
protected override void DoTick()
{
BehaviorTreeStatus status = m_Child.Tick();
ProcessChildStatus(status);
}
protected virtual void OnChildExecuted(BehaviorTreeStatus status)
{
}
