/// <summary>
/// Behave
/// </summary>
/// <param name="status">Status of BehaviorTree</param>
/// <returns>Result of action</returns>
protected override BehaviorResult Behave(BehaviorTreeStatus status)
{
if (AlreadyUpdated)
{
AlreadyUpdated = false;
return(ProcessResult(this.Result));
}
BehaviorResult result = BehaviorResult.Failure;// by default failure
// execute handler and get result back
if (_Handler != null)
{
result = _Handler(this, status.Parameters);
}
status.ChangePosture(this.ChangePosture);
// if action needs to run next frame store it's reference
if (result == BehaviorResult.Running)
{
status.RunningActions.Add(this, status.Parameters);
}
else
{
status.RunningActions.Remove(this);
}
return(ProcessResult(result));
}
/// <summary>
/// Behave
/// </summary>
/// <param name="status">Status of BehaviorTree</param>
/// <returns>Result</returns>
protected override BehaviorResult Behave(BehaviorTreeStatus status)
{
if (Priority == PriorityType.HighestPriority || RunningChildIndex < 0)
{
RunningChildIndex = 0;
}
BehaviorResult result = BehaviorResult.Failure;
for (int i = RunningChildIndex; i < ChildCount; i++)
{
if (status.IsInterrupted)
{
break;
}
BehaviorContainer node = this[i];
status.Parameters = node.Parameters;
node.Execute(status);
result = node.Result;
if (result == BehaviorResult.Running)
{
RunningChildIndex = i;
break;
}
else
{
RunningChildIndex = -1;
}
if (result == BehaviorResult.Success)
{
ResetNext(i, status);
break;
}
}
return(result);
}
/// <summary>
/// Reset behavior. For internal use. when a branch with higher priority executed, let nodes in previous branch reset (internal use)
/// </summary>
/// <param name="status">Status of BehaviorTree</param>
public virtual void ResetBehavior(BehaviorTreeStatus status)
{
if (Result == BehaviorResult.Running && LastUpdateId != status.UpdateId)
{
Result = BehaviorResult.Failure;
}
}
// update action manually when action is running
internal void UpdateImmediately(BehaviorTreeStatus status)
{
try
{
// execute handler and get result back
if (this._Handler != null)
{
this.Result = ProcessResult(this._Handler(this, status.Parameters));
}
else
{
this.Result = ProcessResult(BehaviorResult.Failure);// by default failure
}
this.AlreadyUpdated = true;
// we do not remove action from RunningActions here because this method called inside a foreach of RunningActions
// and we can not modify list inside foreach
}
catch (Exception ex)
{
status.Exception = ex;
this.Result = BehaviorResult.Failure;
return;
}
}
/// <summary>
/// Behave
/// </summary>
/// <param name="status">Status od BehaviorTree</param>
/// <returns></returns>
protected override BehaviorResult Behave(BehaviorTreeStatus status)
{
BehaviorResult result = BehaviorResult.Failure;
if (Child != null)
{
if (_Handler != null)
{
if (Result == BehaviorResult.Running)// continue execution of child
{
result = TraceChild(status);
}
else if (_Handler(this, status.Parameters))
{
result = TraceChild(status);
}
}
else
{
result = TraceChild(status);
}
}
if (NeverFail && result == BehaviorResult.Failure)
{
result = BehaviorResult.Success;
}
return(result);
}
/// <summary>
/// Behave
/// </summary>
/// <param name="status">Status of BehaviorTree</param>
/// <returns>Result of action</returns>
protected override BehaviorResult Behave(BehaviorTreeStatus status)
{
if (status.Tree != null)
{
status.Tree.ChangeState(DestinationState);
}
return(BehaviorResult.Success);
}
private void ResetNext(int index, BehaviorTreeStatus status)
{
for (int i = index + 1; i < ChildCount; i++)
{
BehaviorContainer node = this[i];
node.Behavior.ResetBehavior(status);
}
}
/// <summary>
/// Reset behavior
/// </summary>
/// <param name="status">Status of BehaviorTree</param>
public override void ResetBehavior(BehaviorTreeStatus status)
{
if (Result == BehaviorResult.Running && status.UpdateId != LastUpdateId)
{
_LoopCounter = 0;
}
base.ResetBehavior(status);
}
/// <summary>
/// Reset behavior. For internal use. when a branch with higher priority executed, let nodes in previous branch reset
/// </summary>
/// <param name="status">Status of BehaviorTree</param>
public override void ResetBehavior(BehaviorTreeStatus status)
{
if (Result == BehaviorResult.Running)
{
if (LastUpdateId != status.UpdateId)
{
ResetChildrenExecution();
}
}
base.ResetBehavior(status);
}
/// <summary>
/// Reset behavior
/// </summary>
/// <param name="status">Status of BehaviorTree</param>
public override void ResetBehavior(BehaviorTreeStatus status)
{
if (Result == BehaviorResult.Running)
{
if (Child != null)
{
Child.Behavior.ResetBehavior(status);
}
}
base.ResetBehavior(status);
}
/// <summary>
/// Trace Child - subclasses should implement this method
/// </summary>
/// <param name="status">Status od BehaviorTree</param>
/// <returns></returns>
protected virtual BehaviorResult TraceChild(BehaviorTreeStatus status)
{
BehaviorResult result = BehaviorResult.Failure;
if (Child != null)
{
status.Parameters = Child.Parameters;
Child.Execute(status);
result = Child.Result;
}
return(result);
}
/// <summary>
/// Reset behavior. For internal use. when a branch with higher priority executed, let nodes in previous branch reset
/// </summary>
/// <param name="status">Status of BehaviorTree</param>
public override void ResetBehavior(BehaviorTreeStatus status)
{
if (_Lock && Result == BehaviorResult.Running)
{
if (LastUpdateId != status.UpdateId)
{
AccessKey.Unlock();
_Lock = false;
}
}
base.ResetBehavior(status);
}
/// <summary>
/// Behave
/// </summary>
/// <param name="status">Status of BehaviorTree</param>
/// <returns>esult</returns>
protected override BehaviorResult Behave(BehaviorTreeStatus status)
{
BehaviorResult result = BehaviorResult.Failure;
if (RunningChildIndex < 0)
{
RunningChildIndex = 0;
}
for (int i = RunningChildIndex; i < ChildCount; i++)
{
if (status.IsInterrupted)
{
break;
}
BehaviorContainer node = this[i];
status.Parameters = node.Parameters;
node.Execute(status);
result = node.Result;
if (result == BehaviorResult.Running)
{
RunningChildIndex = i;
break;
}
else
{
RunningChildIndex = -1;
}
if (result == BehaviorResult.Failure)
{
break;
}
}
if (result == BehaviorResult.Success) // cause loop next update and begin from child 0
{
_LoopCounter++;
if (LoopCount > 0 && _LoopCounter >= LoopCount)
{
result = BehaviorResult.Success;
_LoopCounter = 0;
}
else
{
result = BehaviorResult.Running;
}
RunningChildIndex = 0;
}
else if (result == BehaviorResult.Failure)
{
_LoopCounter = 0;
}
return(result);
}
/// <summary>
/// Reset behavior. For internal use. when a branch with higher priority executed, let nodes in previous branch reset
/// </summary>
/// <param name="status">Status of BehaviorTree</param>
public override void ResetBehavior(BehaviorTreeStatus status)
{
if (Result == BehaviorResult.Running)
{
if (LastUpdateId != status.UpdateId)
{
if (status.RunningActions.Remove(this))
{
OnReset();
base.ResetBehavior(status);
}
}
}
}
/// <summary>
/// handle execution of behavior and call appropriate events
/// </summary>
/// <param name="status">Status of BehaviorTree</param>
/// <returns>Result of execution</returns>
public BehaviorResult Execute(BehaviorTreeStatus status)
{
LastUpdateId = status.UpdateId;
try
{
Result = Behave(status);// let subclass behave
}
catch (Exception e)
{
status.Exception = e; // store exception
Result = BehaviorResult.Failure; // set result to failure
}
return(Result);
}
/// <summary>
/// iterate throw children and evaluate conditions
/// </summary>
/// <param name="status">Status of BehaviorTree</param>
/// <returns></returns>
private BehaviorResult CheckConditions(BehaviorTreeStatus status)
{
BehaviorResult result = BehaviorResult.Success;
for (int i = 0; i < ChildCount; i++)
{
BehaviorContainer node = this[i];
status.Parameters = node.Parameters;
if (node.Behavior.Type == BehaviorType.Condition)
{
node.Execute(status);
BehaviorResult r = node.Result;
if (r == BehaviorResult.Failure)
{
if (BreakOnConditionFailure && node.Behavior.Type == BehaviorType.Condition)
{
result = BehaviorResult.Failure;
break;
}
else
{
_FailureCount++;
}
}
// check failure policity
if ((FailurePolicy == AI.FailurePolicy.FailOnOne && _FailureCount > 0) || (FailurePolicy == AI.FailurePolicy.FailOnAll && _FailureCount == ChildCount))
{
result = BehaviorResult.Failure;
break;
}
// check success policity
if (SuccessPolicy == AI.SuccessPolicy.SucceedOnOne && r == BehaviorResult.Success)
{
result = BehaviorResult.Success;
break;
}
// diable these lines because : conditions returns success or failure as result
// if result of this node is running or result of any previous node is running, set result to running
//if (r == BehaviorResult.Running || result != BehaviorResult.Running)
//result = r;
}
}
return(result);
}
/// <summary>
/// Behave
/// </summary>
/// <param name="status">Status of BehaviorTree</param>
/// <returns></returns>
protected override BehaviorResult Behave(BehaviorTreeStatus status)
{
BehaviorResult result = BehaviorResult.Failure;
if (_Handler != null)
{
bool b = _Handler(this, status.Parameters);
if (Reverse)
{
result = b ? BehaviorResult.Failure : BehaviorResult.Success;
}
else
{
result = b ? BehaviorResult.Success : BehaviorResult.Failure;
}
}
return(result);
}
/// <summary>
/// Behave
/// </summary>
/// <param name="status">Status od BehaviorTree</param>
/// <returns>Result</returns>
protected override BehaviorResult Behave(BehaviorTreeStatus status)
{
if (RunningChildIndex < 0)
{
RunningChildIndex = GetRandomIndex();// pick random node
}
BehaviorResult result = BehaviorResult.Failure;
BehaviorContainer node = this[RunningChildIndex];
status.Parameters = node.Parameters;
node.Execute(status);
result = node.Result;
if (result != BehaviorResult.Running)
{
RunningChildIndex = -1;
}
return(result);
}
/// <summary>
/// Reset behavior. For internal use. when a branch with higher priority executed, let nodes in previous branch reset
/// </summary>
/// <param name="status">Status of BehaviorTree</param>
public override void ResetBehavior(BehaviorTreeStatus status)
{
if (Result == BehaviorResult.Running)
{
if (LastUpdateId != status.UpdateId)
{
RunningChildIndex = -1;
}
foreach (var child in this)
{
if (child != null)
{
child.Behavior.ResetBehavior(status);
}
}
}
base.ResetBehavior(status);
}
/// <summary>
/// Behave
/// </summary>
/// <param name="status">Status of BehaviorTree</param>
/// <returns>Result</returns>
//protected override BehaviorResult Behave(BehaviorStatus status)
//{
// BehaviorResult result = BehaviorResult.Failure;
// if (Child != null)
// {
// if (AccessKey != null)
// {
// if (!_Lock)// if do not access to key
// _Lock = AccessKey.Lock();// try to lock key
// if (_Lock)// if success, execute child
// {
// status.Parameters = Child.Parameters;
// result = Child.Behavior.Trace(status);
// }
// if (_Lock && result != BehaviorResult.Running)// if finish job, unlock key
// {
// AccessKey.Unlock();
// _Lock = false;
// }
// }
// }
// if (NeverFail && result == BehaviorResult.Failure)
// result = BehaviorResult.Success;
// return result;
//}
protected override BehaviorResult TraceChild(BehaviorTreeStatus status)
{
BehaviorResult result = BehaviorResult.Failure;
if (AccessKey != null)
{
if (!_Lock) // if do not access to key
{
_Lock = AccessKey.Lock(); // try to lock key
}
if (_Lock) // if success, execute child
{
result = base.TraceChild(status);
}
if (_Lock && result != BehaviorResult.Running)// if finish job, unlock key
{
AccessKey.Unlock();
_Lock = false;
}
}
return(result);
}
/// <summary>
/// Behave
/// </summary>
/// <param name="status">Status od BehaviorTree</param>
/// <returns>Result</returns>
protected override BehaviorResult Behave(BehaviorTreeStatus status)
{
BehaviorResult result = BehaviorResult.Failure;
if (RunningChildIndex < 0)
{
RunningChildIndex = 0;
}
for (int i = RunningChildIndex; i < ChildCount; i++)
{
if (status.IsInterrupted)
{
break;
}
BehaviorContainer node = this[i];
status.Parameters = node.Parameters;
node.Execute(status);
result = node.Result;
if (result == BehaviorResult.Running)
{
RunningChildIndex = i;
break;
}
else
{
RunningChildIndex = -1;
}
if (result == BehaviorResult.Failure)
{
break;
}
}
if (result != BehaviorResult.Running)
{
RunningChildIndex = -1;
}
return(result);
}
/// <summary>
/// Behave
/// </summary>
/// <param name="status">status of BehaviorTree</param>
/// <returns>Result</returns>
protected override BehaviorResult Behave(BehaviorTreeStatus status)
{
_FailureCount = 0;
_SuccessCount = 0;
CreateChildrenExecution(); // make sure the _ChildrenResults array is valid
BehaviorResult result = BehaviorResult.Running; // by default running
// iterate throw children an execute them
for (int i = 0; i < ChildCount; i++)
{
if (status.IsInterrupted)
{
ResetChildrenExecution();
break;
}
BehaviorContainer node = this[i];
status.Parameters = node.Parameters;
if (_ChildrenExecution[i])
{
if (node.Behavior.Concurrency == ConcurrencyMode.UntilFailure && node.Behavior.Result == BehaviorResult.Failure)
{
_FailureCount++;
if ((FailurePolicy == AI.FailurePolicy.FailOnOne && _FailureCount > 0) || (FailurePolicy == AI.FailurePolicy.FailOnAll && _FailureCount == ChildCount))
{
result = BehaviorResult.Failure;
break;
}
continue;
}
else if (node.Behavior.Concurrency == ConcurrencyMode.UntilSuccess && node.Behavior.Result == BehaviorResult.Success)
{
_SuccessCount++;
if (SuccessPolicy == AI.SuccessPolicy.SucceedOnAll)
{
if (_SuccessCount == ChildCount)
{
result = BehaviorResult.Success;
break;
}
}
continue;
}
}
// if this node executed first ignore it
//if (FirstConditions && node.Behavior.Type == BehaviorType.Condition) continue;
node.Execute(status);// execute child node
BehaviorResult childResult = node.Result;
if (childResult == BehaviorResult.Failure)
{
if (BreakOnConditionFailure && node.Behavior.Type == BehaviorType.Condition)
{
result = BehaviorResult.Failure;
break;
}
else
{
_FailureCount++;
}
}
else if (childResult == BehaviorResult.Success)
{
_SuccessCount++;
}
// check failure policity
if ((FailurePolicy == AI.FailurePolicy.FailOnOne && _FailureCount > 0) || (FailurePolicy == AI.FailurePolicy.FailOnAll && _FailureCount == ChildCount))
{
result = BehaviorResult.Failure;
break;
}
// check success policity
if (SuccessPolicy == AI.SuccessPolicy.SucceedOnOne)
{
if (childResult == BehaviorResult.Success)
{
result = BehaviorResult.Success;
break;
}
}
else if (SuccessPolicy == AI.SuccessPolicy.SucceedOnAll)
{
if (_SuccessCount == ChildCount)
{
result = BehaviorResult.Success;
break;
}
}
//// if result of this node is running or result of any previous node is running, set result to running
//if (childResult == BehaviorResult.Running || result != BehaviorResult.Running)
// result = childResult;
_ChildrenExecution[i] = true;
}
if (result != BehaviorResult.Running)
{
ResetChildrenExecution();
}
return(result);
}
public void Execute(BehaviorTreeStatus status)
{
status.RegisterForExecution(this); // register in execution sequence
Result = Behavior.Execute(status);
}
/// <summary> /// Let subclass implement behaveior /// </summary> /// <param name="status">Status of BehaviorTre</param> /// <returns>Result of behavior</returns> protected abstract BehaviorResult Behave(BehaviorTreeStatus status);
/// <summary>
/// for internal use when behavior tree let action continue (when result is BehaviorResult.Running)
/// </summary>
/// <param name="status">Status of BehaviorTree</param>
/// <returns>Result</returns>
internal BehaviorResult Continue(BehaviorTreeStatus status)
{
return(Behave(status));
}
