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); }