public override BehaviorResult Exec(IBehaviorTree tree)
{
if (ActionNode == null)
{
// Debug.LogError("missing action node");
return(BehaviorResult.failed);
}
SetStarting();
BehaviorResult result = ActionNode.Exec(tree);
if (result == BehaviorResult.success)
{
SetCompleted();
return(BehaviorResult.success);
}
else if (result == BehaviorResult.running)
{
return(BehaviorResult.running);
}
else if (result == BehaviorResult.failed)
{
SetFailed();
return(BehaviorResult.failed);
}
else
{
SetAborted();
return(BehaviorResult.abort);
}
}
/// <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);
}
public BehaviorResult Behave(AIContext context)
{
if (HasProcessedAllNodes)
{
return(InvokeAndReturn());
}
var currentNode = pendingNodes.Pop();
switch (behaviorResult = currentNode.Behave(context))
{
case BehaviorResult.Failure:
Behave(context);
break;
case BehaviorResult.Running:
//reevaluate the next iteration
pendingNodes.Push(currentNode);
return(InvokeAndReturn());
case BehaviorResult.Success:
//stop iterating nodes
pendingNodes.Clear();
break;
}
return(InvokeAndReturn());
}
public override BehaviorResult Exec(IBehaviorTree tree)
{
if (OnAction == null)
{
return(BehaviorResult.failed);
}
if (!Running)
{
if (OnPrecondition != null)
{
if (!OnPrecondition())
{
return(BehaviorResult.failed);
}
}
SetStarting();
}
BehaviorResult result = OnAction();
if (result == BehaviorResult.success)
{
SetCompleted();
}
else if (result == BehaviorResult.failed)
{
SetFailed();
}
return(result);
}
public override BehaviorResult Update()
{
BehaviorResult behaviorResult = base.Update();
if (behaviorResult != BehaviorResult.Continue)
{
return(behaviorResult);
}
if (!this.IsReady())
{
return(BehaviorResult.Continue);
}
this.m_enemyPrefab = EnemyDatabase.GetOrLoadByGuid(this.m_aiActor.EnemyGuid);
this.m_aiAnimator.PlayUntilFinished(this.Anim, true, null, -1f, false);
if (this.AnimRequiresTransparency)
{
this.m_cachedShader = this.m_aiActor.renderer.material.shader;
this.m_aiActor.sprite.usesOverrideMaterial = true;
this.m_aiActor.SetOutlines(false);
this.m_aiActor.renderer.material.shader = ShaderCache.Acquire("Brave/LitBlendUber");
}
this.m_aiActor.ClearPath();
this.m_timer = this.SpawnDelay;
if (this.m_aiActor && this.m_aiActor.knockbackDoer)
{
this.m_aiActor.knockbackDoer.SetImmobile(true, "MirrorImageBehavior");
}
this.m_aiActor.IsGone = true;
this.m_aiActor.specRigidbody.CollideWithOthers = false;
this.m_actorsToSplit.Clear();
this.m_actorsToSplit.Add(this.m_aiActor);
this.m_state = FriendlyMirrorImageBehavior.State.Summoning;
this.m_updateEveryFrame = true;
return(BehaviorResult.RunContinuous);
}
public override BehaviorResult Exec(IBehaviorTree tree)
{
if (TargetNode == null)
{
return(BehaviorResult.failed);
}
SetStarting();
BehaviorResult result = TargetNode.Exec(tree);
if (result == BehaviorResult.success)
{
SetCompleted();
return(BehaviorResult.success);
}
else if (result == BehaviorResult.failed)
{
SetFailed();
return(BehaviorResult.failed);
}
else if (result == BehaviorResult.running)
{
return(BehaviorResult.running);
}
SetAborted();
return(BehaviorResult.abort);
}
/// <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);
}
public override BehaviorResult Update()
{
if (m_shadowSprite == null)
{
m_shadowSprite = m_aiActor.ShadowObject.GetComponent <tk2dBaseSprite>();
}
BehaviorResult behaviorResult = base.Update();
if (behaviorResult != BehaviorResult.Continue)
{
return(behaviorResult);
}
if (!IsReady())
{
return(BehaviorResult.Continue);
}
if (!m_aiActor.TargetRigidbody)
{
return(BehaviorResult.Continue);
}
m_dashDirection = GetDashDirection();
if (!string.IsNullOrEmpty(chargeAnim))
{
State = DashState.Charge;
}
else
{
State = DashState.Dash;
}
m_updateEveryFrame = true;
return(BehaviorResult.RunContinuous);
}
/// <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));
}
public override BehaviorResult Exec(IBehaviorTree tree)
{
if (m_ChildNodes.Count == 0)
{
// Debug.LogError("missing sequence children node");
return(BehaviorResult.failed);
}
if (!Running)
{
if (OnPrecondition != null)
{
if (!OnPrecondition())
{
SetFailed();
return(BehaviorResult.failed);
}
}
SetStarting();
}
if (nodes == null)
{
nodes = new List <BehaviorNode>(m_ChildNodes);
nodes.Sort(delegate(BehaviorNode x, BehaviorNode y) { return(tree.RandomMgr.Next(-1, 1)); });
}
while (true)
{
if (currentIndex >= nodes.Count)
{
break;
}
BehaviorResult result = nodes[currentIndex].Exec(tree);
if (result == BehaviorResult.running)
{
return(BehaviorResult.running);
}
else if (result == BehaviorResult.failed)
{
SetFailed();
return(BehaviorResult.failed);
}
else if (result == BehaviorResult.success)
{
currentIndex++;
if (currentIndex == m_ChildNodes.Count)
{
SetCompleted();
return(result);
}
}
}
SetCompleted();
return(BehaviorResult.success);
}
internal void ExitAttack(BehaviorResult result)
{
mState = UnitState.kIdel;
#if DEBUG
Debug.Log(Unit.ID + " ExitAttack");
#endif
}
public BehaviorResult Behave(AIContext context)
{
var behaviorTestResult = behaviorTest(context);
behaviorResult = behaviorTestResult ?
BehaviorResult.Success : BehaviorResult.Failure;
return(InvokeAndReturn());
}
public BehaviorResult Behave(AIContext context)
{
writeDebugInfo(Environment.NewLine + "Invoking " + debugName);
behaviorResult = decoratedNode.Behave(context);
writeDebugInfo(debugName + " execution terminated: " + behaviorResult);
OnBehaved?.Invoke(this, new BehaviorInvokationEventArgs(behaviorResult));
return(behaviorResult);
}
public override BehaviorResult Exec(IBehaviorTree tree)
{
if (TargetNode == null)
{
//Debug.LogError("missing target node");
return(BehaviorResult.failed);
}
if (!Running)
{
if (OnPrecondition != null)
{
if (!OnPrecondition())
{
return(BehaviorResult.failed);
}
}
SetStarting();
}
if (N == 0.0f)
{
N = tree.GameTime;
}
BehaviorResult result = TargetNode.Exec(tree);
if (result == BehaviorResult.success)
{
SetCompleted();
N = 0.0f;
return(BehaviorResult.success);
}
else if (result == BehaviorResult.failed)
{
SetFailed();
return(BehaviorResult.failed);
}
else if (result == BehaviorResult.running)
{
if (tree.GameTime - N < Interval)
{
return(BehaviorResult.running);
}
else
{
TargetNode.Abort();
N = 0.0f;
return(BehaviorResult.failed);
}
}
else
{
return(BehaviorResult.abort);
}
}
public override BehaviorResult Exec(IBehaviorTree tree)
{
if (m_ChildNodes.Count == 0)
{
return(BehaviorResult.failed);
}
SetStarting();
while (true)
{
if (curNode == null)
{
curNode = CheckPreconditionChild();
}
if (curNode != null)
{
//每次都重新检查子节点条件
BehaviorWithPreconditonNode newNode = CheckPreconditionChild();
if (newNode != curNode)
{
curNode.Abort();
curNode = newNode;
if (curNode == null)
{
// 等待到下一帧再跳到循环开头继续检测
return(BehaviorResult.running);
}
}
BehaviorResult result = curNode.Exec(tree);
if (result == BehaviorResult.success)
{
SetCompleted();
return(BehaviorResult.success);
}
else if (result == BehaviorResult.failed)
{
// 子节点执行失败时不退出，继续选择
curNode = null;
return(BehaviorResult.running);
}
else if (result == BehaviorResult.running)
{
return(BehaviorResult.running);// 等待一帧
}
}
else
{
return(BehaviorResult.running);
}
}
}
public override BehaviorResult Exec(IBehaviorTree tree)
{
if (m_ChildNodes.Count == 0)
{
// Debug.LogError("missing select children node");
return(BehaviorResult.failed);
}
if (!Running)
{
if (OnPrecondition != null)
{
if (!OnPrecondition())
{
return(BehaviorResult.failed);
}
}
SetStarting();
}
// 概率
if (Probability == -1)
{
Probability = tree.RandomMgr.Next(0, 100);
}
while (true)
{
if (currentIndex >= m_RunningNodes.Count)
{
break;
}
if (Probability <= (m_RunningNodes[currentIndex] as BehaviorProbabilityWeightNode).Weight)
{
BehaviorResult result = m_RunningNodes[currentIndex].Exec(tree);
if (result == BehaviorResult.success)
{
SetCompleted();
return(BehaviorResult.success);
}
else if (result == BehaviorResult.running)
{
return(BehaviorResult.running);
}
else if (result == BehaviorResult.failed)
{
currentIndex++;
}
}
}
SetFailed();
return(BehaviorResult.failed);
}
private BehaviorResult ProcessResult(BehaviorResult result)
{
if (result == BehaviorResult.Running)
{
IsBegined = true;
}
else
{
IsBegined = false;
}
return(result);
}
public void Should_Return_Expected_Result_Depending_On_Behaviors_Result(BehaviorResult state, BehaviorResult expected)
{
// Given
var context = new BehaviorContext();
var selector = new Inverter(new PredictableBehavior(state));
// When
var result = selector.OnBehave(context);
// Then
Assert.Equal(expected, result);
}
/// <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>
/// 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);
}
public override BehaviorResult Exec(IBehaviorTree tree)
{
if (m_ChildNodes.Count == 0)
{
// Debug.LogError("missing sequence children node");
return(BehaviorResult.failed);
}
if (!Running)
{
if (OnPrecondition != null)
{
if (!OnPrecondition())
{
SetFailed();
return(BehaviorResult.failed);
}
}
SetStarting();
}
// var runingNode = m_ChildNodes[currentIndex];
while (true)
{
if (currentIndex >= m_ChildNodes.Count)
{
break;
}
BehaviorResult result = m_ChildNodes[currentIndex].Exec(tree);
if (result == BehaviorResult.success)
{
currentIndex++;
if (currentIndex == m_ChildNodes.Count)
{
SetCompleted();
return(result);
}
}
else if (result == BehaviorResult.failed)
{
SetFailed();
return(result);
}
else if (result == BehaviorResult.running)
{
return(result);
}
}
SetFailed();
return(BehaviorResult.failed);
}
public override BehaviorResult Exec(IBehaviorTree tree)
{
if (OnCondition == null)
{
// Debug.LogError("missing condition event method");
return(BehaviorResult.failed);
}
if (TrueNode == null)
{
//Debug.LogError("missing true node");
return(BehaviorResult.failed);
}
if (FalseNode == null)
{
// Debug.LogError("missing false node");
return(BehaviorResult.failed);
}
if (!Running)
{
if (OnCondition())
{
m_BranchNode = TrueNode;
}
else
{
m_BranchNode = FalseNode;
}
SetStarting();
}
BehaviorResult result = m_BranchNode.Exec(tree);
if (result == BehaviorResult.success)
{
SetCompleted();
return(BehaviorResult.success);
}
else if (result == BehaviorResult.running)
{
return(BehaviorResult.running);
}
else if (result == BehaviorResult.failed)
{
SetFailed();
return(BehaviorResult.failed);
}
SetAborted();
return(BehaviorResult.abort);
}
public override BehaviorResult Update()
{
base.Update();
if (!m_initialized)
{
SpeculativeRigidbody specRigidbody = m_aiActor.specRigidbody;
specRigidbody.OnCollision = (Action <CollisionData>)Delegate.Combine(specRigidbody.OnCollision, new Action <CollisionData>(OnCollision));
m_initialized = true;
}
BehaviorResult behaviorResult = base.Update();
if (behaviorResult != BehaviorResult.Continue)
{
return(behaviorResult);
}
if (!IsReady())
{
return(BehaviorResult.Continue);
}
if (!m_aiActor.TargetRigidbody)
{
return(BehaviorResult.Continue);
}
Vector2 vector = m_aiActor.TargetRigidbody.specRigidbody.GetUnitCenter(ColliderType.HitBox);
if (leadAmount > 0f)
{
Vector2 b = vector + m_aiActor.TargetRigidbody.specRigidbody.Velocity * 0.75f;
b = BraveMathCollege.GetPredictedPosition(vector, m_aiActor.TargetVelocity, m_aiActor.specRigidbody.UnitCenter, chargeSpeed);
vector = Vector2.Lerp(vector, b, leadAmount);
}
float num = Vector2.Distance(m_aiActor.specRigidbody.UnitCenter, vector);
if (num > minRange)
{
if (!string.IsNullOrEmpty(primeAnim) || primeTime > 0f)
{
State = FireState.Priming;
}
else
{
State = FireState.Charging;
}
m_updateEveryFrame = true;
return(BehaviorResult.RunContinuous);
}
return(BehaviorResult.Continue);
}
public override BehaviorResult Exec(IBehaviorTree tree)
{
if (m_ChildNodes.Count == 0)
{
return BehaviorResult.failed;
}
if (! Running)
{
if (OnPrecondition != null)
{
if (!OnPrecondition())
{
return BehaviorResult.failed;
}
}
SetStarting();
}
while (m_RunningList.Count > 0)
{
if (currentNode == null)
{
int index = tree.RandomMgr.Next(0, m_RunningList.Count - 1);
currentNode = m_RunningList[index];
m_RunningList.RemoveAt(index);
}
BehaviorResult result = currentNode.Exec(tree);
if(result == BehaviorResult.running)
{
return BehaviorResult.running;
}
else if(result == BehaviorResult.success)
{
SetCompleted();
return BehaviorResult.success;
}
else if(result == BehaviorResult.failed)
{
return BehaviorResult.running;
}
}
SetFailed();
return BehaviorResult.failed;
}
private void Update()
{
_myresult = _myTree.ExecuteTree();
switch (_myresult)
{
case BehaviorResult.FAIL:
case BehaviorResult.SUCCESS:
_myTree.ResetTree();
_myTree.InitializeTree();
break;
case BehaviorResult.RUNNING:
break;
}
}
public BehaviorResult Behave(AIContext context)
{
if (behaviorResult != BehaviorResult.Running)
{
return(InvokeAndReturn());
}
switch (decoratedNode.Behave(context))
{
case BehaviorResult.Success:
case BehaviorResult.Failure:
behaviorResult = BehaviorResult.Success;
break;
}
return(InvokeAndReturn());
}
public BehaviorResult Behave(AIContext context)
{
if (behaviorResult == BehaviorResult.Failure)
{
InvokeAndReturn();
}
behaviorResult = decoratedNode.Behave(context);
if (behaviorResult == BehaviorResult.Success)
{
decoratedNode = repeatedDecoratedNode();
behaviorResult = BehaviorResult.Running;
}
return(InvokeAndReturn());
}
public override BehaviorResult Exec(IBehaviorTree tree)
{
if (TargetNode == null)
{
return(BehaviorResult.failed);
}
if (!Running)
{
if (OnPrecondition != null)
{
if (!OnPrecondition())
{
return(BehaviorResult.failed);
}
}
SetStarting();
}
while (true)
{
if (N == 0.0f)
{
N = tree.GameTime;
}
while (tree.GameTime - N < CDTime)
{
return(BehaviorResult.running);
}
BehaviorResult result = TargetNode.Exec(tree);
if (result == BehaviorResult.success)
{
Reset();
}
else if (result == BehaviorResult.failed)
{
Reset();
}
else if (result == BehaviorResult.running)
{
return(BehaviorResult.running);
}
}
}
/// <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);
}
