protected override BTResult OnTick(ref BTInput _input)
{
BTResult result = BTResult.Success;
if (mStatus == BTStatus.Ready)
{
OnEnter(_input);
mNeedExit = true;
mStatus = BTStatus.Running;
}
if (mStatus == BTStatus.Running)
{
result = OnExecute(ref _input);
if (result == BTResult.Success || result == BTResult.Failed)
{
mStatus = BTStatus.Finish;
}
}
if (mStatus == BTStatus.Finish)
{
if (mNeedExit)
{
OnExit(_input, result);
}
mStatus = BTStatus.Ready;
mNeedExit = false;
}
return(result);
}
protected override BTRunningStatus DoTick(BTInput input, ref BTOutput output)
{
base.DoTick(input, ref output);
var runningStatus = BTRunningStatus.Finish;
if (_lastSelectIndex != -1 && _lastSelectIndex != _currentSelectIndex)
{
var node = _childNodes[_lastSelectIndex];
node.Transition(input);
_lastSelectIndex = _currentSelectIndex;
}
if (_lastSelectIndex != -1)
{
var node = _childNodes[_lastSelectIndex];
runningStatus = node.Tick(input, ref output);
if (runningStatus == BTRunningStatus.Finish)
{
_lastSelectIndex = -1;
}
}
return(runningStatus);
}
protected override BTResult OnTick(ref BTInput _input)
{
BTResult result = BTResult.Success;
//First Time
if (mCurrentIndex == INVALID_CHILD_NODE_INDEX)
{
mCurrentIndex = 0;
}
BTNode node = mChildren[mCurrentIndex];
result = node.Tick(ref _input);
if (result == BTResult.Success)
{
mCurrentIndex++;
if (mCurrentIndex == childCount)
{
mCurrentIndex = INVALID_CHILD_NODE_INDEX;
}
else
{
result = BTResult.Executing;
}
}
if (result == BTResult.Failed)
{
mCurrentIndex = INVALID_CHILD_NODE_INDEX;
}
return(result);
}
protected override BTResult OnTick(ref BTInput _input)
{
BTResult result = BTResult.Success;
if (CheckIndex(0))
{
BTNode node = mChildren[0];
result = node.Tick(ref _input);
if (result == BTResult.Success)
{
if (loopCount != INFINITELOOP)
{
mCurrentCount++;
if (mCurrentCount == loopCount)
{
result = BTResult.Executing;
}
}
else
{
result = BTResult.Executing;
}
}
}
if (result == BTResult.Success)
{
mCurrentCount = 0;
}
return(result);
}
protected override BTRunningStatus DoTick(BTInput input, ref BTOutput output)
{
base.DoTick(input, ref output);
var runningStatus = BTRunningStatus.Finish;
if (_currentNodeIndex == -1)
{
_currentNodeIndex = 0;
}
var node = _childNodes[_currentNodeIndex];
runningStatus = node.Tick(input, ref output);
if (runningStatus == BTRunningStatus.Finish)
{
_currentNodeIndex++;
if (_currentNodeIndex == _childNodes.Count)
{
_currentNodeIndex = -1;
}
else
{
runningStatus = BTRunningStatus.Executing;
}
}
else if (runningStatus == BTRunningStatus.Error)
{
_currentNodeIndex = -1;
}
return(runningStatus);
}
protected override BTRunningStatus DoTick(BTInput input, ref BTOutput output)
{
BTRunningStatus runningStatus = base.DoTick(input, ref output);
switch (_status)
{
case BTNodeStatus.Ready:
DoEnter(input);
_needExit = true;
_status = BTNodeStatus.Running;
SetActiveNode(this);
break;
case BTNodeStatus.Running:
runningStatus = DoExecute(input, ref output);
SetActiveNode(this);
if (runningStatus == BTRunningStatus.Finish || runningStatus == BTRunningStatus.Error)
{
_status = BTNodeStatus.Finish;
}
break;
case BTNodeStatus.Finish:
if (_needExit)
{
DoExit(input, runningStatus);
}
_status = BTNodeStatus.Ready;
_needExit = false;
SetActiveNode(null);
break;
}
return(runningStatus);
}
protected override BTResult OnTick(ref BTInput _input)
{
BTResult result = BTResult.Success;
if (CheckIndex(mCurrentSelectIndex))
{
if (mLastSelectIndex != mCurrentSelectIndex)
{
if (CheckIndex(mLastSelectIndex))
{
BTNode node = mChildren[mLastSelectIndex];
node.Transition(_input);
}
mLastSelectIndex = mCurrentSelectIndex;
}
}
if (CheckIndex(mLastSelectIndex))
{
BTNode node = mChildren[mLastSelectIndex];
result = node.Tick(ref _input);
if (result == BTResult.Success)
{
mLastSelectIndex = INVALID_CHILD_NODE_INDEX;
}
}
return(result);
}
protected override bool OnEvaluate(BTInput _input)
{
mCurrentSelectIndex = INVALID_CHILD_NODE_INDEX;
int weight = -1;
for (int i = 0; i < childCount; i++)
{
BTNode node = mChildren[i];
if (node.Evaluate(_input))
{
int w = node.GetWeight();
if (weight == -1 || w > weight)
{
weight = w;
mCurrentSelectIndex = i;
}
}
}
if (CheckIndex(mCurrentSelectIndex))
{
return(true);
}
return(base.OnEvaluate(_input));
}
/// <summary>
/// 执行
/// </summary>
/// <param name="input"></param>
/// <returns></returns>
public override ActionResult Excute(BTInput input)
{
base.Excute(input);
for (int i = this.m_iRuningIndex; i < this.m_listChildren.Count; i++)
{
BNode node = this.m_listChildren[i];
ActionResult res = node.RunNode(input);
if (res == ActionResult.Running)
{
this.m_iRuningIndex = i;
return(ActionResult.Running);
}
}
return(ActionResult.Success);
//if (this.m_iRuningIndex >= this.m_listChildren.Count)
//{
// return ActionResult.Success;
//}
//BNode node = this.m_listChildren[this.m_iRuningIndex];
//ActionResult res = node.RunNode(input);
//if (res != ActionResult.Running)
//{
// this.m_iRuningIndex++;
//}
//return ActionResult.Running;
}
protected override void DoTransition(BTInput input)
{
base.DoTransition(input);
var node = _childNodes[_currentSelectIndex];
node.Transition(input);
_lastSelectIndex = -1;
}
protected override void OnTransition(BTInput _input)
{
if (CheckIndex(mCurrentIndex))
{
BTNode node = mChildren[mCurrentIndex];
node.Transition(_input);
}
mCurrentIndex = INVALID_CHILD_NODE_INDEX;
}
protected override void OnTransition(BTInput _input)
{
for (int i = 0; i < childCount; i++)
{
mChildrenResults[i] = BTResult.Executing;
BTNode node = mChildren[i];
node.Transition(_input);
}
}
protected override void OnTransition(BTInput _input)
{
if (mNeedExit)
{
OnExit(_input, BTResult.Failed);
}
mStatus = BTStatus.Ready;
mNeedExit = false;
}
public virtual ActionResult Excute(BTInput input)
{
//if (input.GetCharacter().m_playerCamp == BattleCommon.ePlayerCamp.Enemy)
//{
// //Debug.LogError("-----------Excute " + m_strName);
//}
return(ActionResult.Success);
}
protected override void OnTransition(BTInput _input)
{
if (CheckIndex(0))
{
BTNode node = mChildren[0];
node.Transition(_input);
}
mCurrentCount = 0;
}
public override bool Check(BTInput _input)
{
AIInput input = _input as AIInput;
if (input != null)
{
return(input.CheckCondition(AIConditionType.HasTarget));
}
return(false);
}
public override void Visit(BTInput input, BTOutput output)
{
//Debug.Log(string.Format("ActionEventNode status={0}", status));
if (status == BehaviourStatus.Ready)
{
status = BehaviourStatus.Running;
output.leafNode = this;
action(input, output);
}
}
public override bool Check(BTInput _input)
{
AIInput input = _input as AIInput;
if (input != null)
{
return(input.CheckCondition(AIConditionType.IsAttackRange));
}
return(false);
}
public void Tick(BTInput input, ref BTOutput output)
{
if (_root.Check(input))
{
_root.Tick(input, ref output);
}
else
{
_root.Transition(input);
}
}
protected override BTResult OnExecute(ref BTInput _input)
{
AIInput input = _input as AIInput;
if (input != null)
{
return(input.DoAction(AIActionType.Attack));
}
return(base.OnExecute(ref _input));
}
public override bool Check(BTInput _input)
{
for (int i = 0; i < mPreconditions.Length; i++)
{
if (!mPreconditions[i].Check(_input))
{
return(false);
}
}
return(true);
}
protected override void DoTransition(BTInput input)
{
base.DoTransition(input);
if (_currentNodeIndex != -1)
{
var node = _childNodes[_currentNodeIndex];
node.Transition(input);
}
_currentNodeIndex = -1;
}
protected override void DoTransition(BTInput _input)
{
base.DoTransition(_input);
if (_needExit)
{
DoExit(_input, BTRunningStatus.Error);
}
SetActiveNode(null);
_status = BTNodeStatus.Ready;
_needExit = false;
}
protected override BTResult OnExecute(ref BTInput _input)
{
AIInput input = _input as AIInput;
if (input != null)
{
return(input.DoAction(AIActionType.Idle));
}
return(BTResult.Success);
}
protected override void DoTransition(BTInput input)
{
base.DoTransition(input);
var childCount = _childNodes.Count;
for (int i = 0; i < childCount; i++)
{
_childNodesStatus[i] = BTRunningStatus.Executing;
var node = _childNodes[i];
node.Transition(input);
}
}
protected override bool OnEvaluate(BTInput _input)
{
if (CheckIndex(mCurrentSelectIndex))
{
BTNode node = mChildren[mCurrentSelectIndex];
if (node.Evaluate(_input))
{
return(true);
}
}
return(base.OnEvaluate(_input));
}
protected override bool OnEvaluate(BTInput _input)
{
for (int i = 0; i < childCount; i++)
{
BTNode node = mChildren[i];
if (node.Evaluate(_input))
{
mCurrentSelectIndex = i;
return(true);
}
}
return(false);
}
public override ActionResult Excute(BTInput input)
{
base.Excute(input);
if (this.m_listChildren.Count == 0)
{
return(ActionResult.Success);
}
BNode node = this.m_listChildren[0];
ActionResult res = node.RunNode(input);
return(res);
}
protected override bool DoCheck(BTInput input)
{
base.DoCheck(input);
BTNodeBase node = _childNodes[_index];
if (node.Check(input))
{
return(true);
}
return(base.DoCheck(input));
}
protected override bool OnEvaluate(BTInput _input)
{
mCurrentSelectIndex = mRandom.Next(0, childCount);
if (CheckIndex(mCurrentSelectIndex))
{
var node = children[mCurrentSelectIndex];
if (node.Evaluate(_input))
{
return(true);
}
}
return(base.OnEvaluate(_input));
}
public void Tick(string config, ref BTInput input)
{
if (string.IsNullOrEmpty(config))
{
return;
}
if (mBattleLogicDic.ContainsKey(config) == false)
{
BTRoot root = new BTRoot();
AIConfig.ReadXML(config, root);
mBattleLogicDic.Add(config, root);
}
mBattleLogicDic[config].Tick(ref input);
}
public override void Visit(BTInput input, BTOutput output)
{
this.status = BehaviourStatus.Success;
output.leafNode = this;
action(input, output);
}
public override void Visit(BTInput input, BTOutput output)
{
var child = this.children[0];
child.Visit(input, output);
if (child.status == BehaviourStatus.Success)
status = BehaviourStatus.Failed;
else if (child.status == BehaviourStatus.Failed)
status = BehaviourStatus.Success;
else
status = child.status;
}
public override void Visit(BTInput input, BTOutput output)
{
output.leafNode = this;
if (_condition != null)
{
if (_condition(input, output))
{
this._status = BehaviourStatus.Success;
}
else
{
this._status = BehaviourStatus.Running;
}
}
else if (_fn != null)
{
object[] res = (object[])_fn.call(input, output);
if (res!=null && res.Length > 0 && res[0].Equals(true))
{
this._status = BehaviourStatus.Success;
}
else
{
this._status = BehaviourStatus.Running;
}
}
else
{
this._status = BehaviourStatus.Failed;
}
}
public override void Visit(BTInput input, BTOutput output)
{
float currTime = Time.unscaledTime;
if (status != BehaviourStatus.Running)
{
wakeTime = currTime + duration+Random.Range(0,variation);
status = BehaviourStatus.Running;
}
if (status == BehaviourStatus.Running)
{
if (currTime >= wakeTime)
status = BehaviourStatus.Success;
}
}
public override void Visit(BTInput input, BTOutput output)
{
if (children.Count >= 1)
{
var child = children[0];
child.Visit(input, output);
if (child.status != BehaviourStatus.Failed)
{
status = child.status;
}
else
{
status = BehaviourStatus.Success;
}
}
else
{
status = BehaviourStatus.Success;
}
}
public override void Visit(BTInput input, BTOutput output)
{
if (status == BehaviourStatus.Ready && !isInit)
{
isInit = true;
//Debug.Log(string.Format("AddEventHandler {0} status ={1} ,actor ={2} ", this.name + (BrainEventEnum)eventType, status, input.actor));
//input.actor.brain.AddEventHandler(eventType, OnEvent);
}
if (status == BehaviourStatus.Ready && triggered)
{
triggered = false;
status = BehaviourStatus.Running;
//Debug.Log(string.Format("BeginRunning EventNode {0} data {1} status ={2}", this.name + (BrainEventEnum)eventType, data, status));
}
//Debug.Log(string.Format("Visit EventNode {0} data {1} status ={2} triggered ={3}", this.name + (BrainEventEnum)eventType, data, status, triggered));
if (status == BehaviourStatus.Running)
{
if (children.Count >= 1)
{
BTOutput oup = output;
oup.eventData = data;
var child = children[0];
child.Visit(input, output);
status = child.status;
oup.eventData = null;
//if (status != BehaviourStatus.Running)
//{
//Debug.Log(string.Format(" EventNode {0} Complete {1} ", this.name, status));
//MyDebug.StackTrace();
//}
}
else
{
status = BehaviourStatus.Failed;
}
}
}
public override void Visit(BTInput input, BTOutput output)
{
if (status != BehaviourStatus.Running)
{
this.currIndex = 0;
this.rep = 0;
}
int len = this.children.Count;
while (this.currIndex < len)
{
IBehaviourNode child = children[this.currIndex];
child.Visit(input, output);
//Debug.Log(string.Format("LoopNode {0},count ={1}rep={2} status={3} child.name ={4} child.status={5}", name, count, rep, status, child.name, child.status));
if (child.status == BehaviourStatus.Running || child.status == BehaviourStatus.Failed)
{
this.status = child.status;
return;
}
else
{
this.status = BehaviourStatus.Running;
}
this.currIndex++;
}
if (currIndex >= len) //从头开始
{
currIndex = 0;//从头开始
rep++;
}
if (rep > count && count>0)
{
this.status = BehaviourStatus.Success;
}
//else
//{
// foreach (var child in children)
// child.Reset();
//}
}
public override void Visit(BTInput input, BTOutput output)
{
bool done = true;
foreach (IBehaviourNode child in children)
{
if (children is ConditionNode)
{
child.Reset();
}
child.Visit(input, output);
if (child.status == BehaviourStatus.Running)
done = false;
else if (child.status == BehaviourStatus.Success)
{
status = child.status;
return;
}
}
if (!done)
this.status = BehaviourStatus.Running;
else
this.status = BehaviourStatus.Failed;
}
public override void Visit(BTInput input, BTOutput output)
{
bool done = true;
bool any_done = false;
foreach (IBehaviourNode child in children)
{
if (children is ConditionNode)
{
child.Reset();
}
if (child.status != BehaviourStatus.Success)
{
child.Visit(input, output);
if (child.status == BehaviourStatus.Failed)
{
this.status = BehaviourStatus.Failed;
return;
}
}
if (child.status == BehaviourStatus.Running)
done = false;
else
any_done = true;
}
if (done || (stopOnAnyComplete && any_done))
this.status = BehaviourStatus.Success;
else
this.status = BehaviourStatus.Running;
}
/// <summary>
/// 开始
/// </summary>
internal void Start()
{
OnStart();
isInit = true;
_input = actor.input;
_output = actor.output;
}
public override void Visit(BTInput input, BTOutput output)
{
float dt = Time.unscaledTime - lastTime;
if (dt > delta)
{
base.Visit(input, output);
lastTime = Time.unscaledTime;
}
else
{
this.status = BehaviourStatus.Success;
}
}
public override void Visit(BTInput input, BTOutput output)
{
float dt = Time.unscaledTime - lastTime; //Debug.Log(string.Format("DeltaConditionNode doit={0} ,dt={1}", dt > delta, dt));
if (dt > delta)
{
output.leafNode = this;
base.Visit(input, output);
lastTime = Time.unscaledTime;
}
else
{
this.status = BehaviourStatus.Failed;
}
}
public override void Visit(BTInput input, BTOutput output)
{
if (status == BehaviourStatus.Ready)
{
int len = this.children.Count - 1;
this.currIndex = Random.Range(0, len);
int start = this.currIndex;
while (true)
{
IBehaviourNode child = children[this.currIndex];
child.Visit(input, output);
if (child.status != BehaviourStatus.Failed)
{
this.status = child.status;
return;
}
this.currIndex++;
if (this.currIndex == len)
this.currIndex = 0;
if (this.currIndex == start)
{
this.status = BehaviourStatus.Failed;
return;
}
}
}
else
{
IBehaviourNode child = children[this.currIndex];
child.Visit(input, output);
this.status = child.status;
}
}
public override void Visit(BTInput input, BTOutput output)
{
if (status != BehaviourStatus.Running)
{
this.currIndex = 0;
}
int len = this.children.Count;
while (this.currIndex < len)
{
IBehaviourNode child = children[this.currIndex];
child.Visit(input, output);
if (child.status == BehaviourStatus.Running)
{
this.status = child.status;
return;
}
else if (child.status == BehaviourStatus.Failed)
{
this.status = BehaviourStatus.Success;
return;
}
this.currIndex++;
}
this.status = BehaviourStatus.Success;
}
public override void Visit(BTInput input, BTOutput output)
{
Actor actor = input.actor;
object data = output.eventData;
if (data != null)
{
//Debug.Log("触发事件" + actor + "=>" + (BrainEventEnum)eventType + " data= " + data);
//actor.brain.DispatchEvent(eventType, data);
status = BehaviourStatus.Success;
}
else
{
status = BehaviourStatus.Failed;
}
}
