protected override BTreeRunningStatus _DoTick(BTreeTemplateData _input, ref BTreeTemplateData _output)
{
base._DoTick(_input, ref _output);
BTreeRunningStatus RunningStatus = BTreeRunningStatus.Finish;
if (_CheckIndex(m_CurrentSelectIndex))
{
if (m_LastSelectIndex != m_CurrentSelectIndex)
{
if (_CheckIndex(m_LastSelectIndex))
{
BTreeNode bn = m_ChildNodes[m_LastSelectIndex];
bn.Transition(_input);
}
m_LastSelectIndex = m_CurrentSelectIndex;
}
}
if (_CheckIndex(m_LastSelectIndex))
{
BTreeNode bn = m_ChildNodes[m_LastSelectIndex];
RunningStatus = bn.Tick(_input, ref _output);
if (RunningStatus == BTreeRunningStatus.Finish)
{
m_LastSelectIndex = INVALID_CHILD_NODE_INDEX;
}
}
return(RunningStatus);
}
protected override BTreeRunningStatus _DoTick(BTreeTemplateData _input, ref BTreeTemplateData _output)
{
BTreeRunningStatus runningStatus = base._DoTick(_input, ref _output);
if (m_Status == BTreeNodeStatus.Ready)
{
_DoEnter(_input);
m_NeedExit = true;
m_Status = BTreeNodeStatus.Running;
SetActiveNode(this);
}
if (m_Status == BTreeNodeStatus.Running)
{
runningStatus = _DoExecute(_input, ref _output);
SetActiveNode(this);
if (runningStatus == BTreeRunningStatus.Finish || runningStatus == BTreeRunningStatus.Error)
{
m_Status = BTreeNodeStatus.Finish;
}
}
if (m_Status == BTreeNodeStatus.Finish)
{
if (m_NeedExit)
{
_DoExit(_input, runningStatus);
}
m_Status = BTreeNodeStatus.Ready;
m_NeedExit = false;
SetActiveNode(null);
}
return(runningStatus);
}
protected override BTreeRunningStatus _DoTick(BTreeTemplateData _input, ref BTreeTemplateData _output)
{
BTreeRunningStatus runningStatus = base._DoTick(_input, ref _output);
if (_CheckIndex(0))
{
BTreeNode bn = m_ChildNodes[0];
runningStatus = bn.Tick(_input, ref _output);
if (runningStatus == BTreeRunningStatus.Finish)
{
if (m_LoopCount != INFINITELOOP)
{
m_CurrentCount++;
if (m_CurrentCount == m_LoopCount)
{
runningStatus = BTreeRunningStatus.Executing;
}
}
else
{
runningStatus = BTreeRunningStatus.Executing;
}
}
}
if (runningStatus == BTreeRunningStatus.Finish)
{
m_CurrentCount = 0;
}
return(runningStatus);
}
public override bool ExternalCondition(BTreeTemplateData input)
{
var _input = (BTreeInputData)input;
var troop = _input.troop;
var battleData = _input.battleData;
if (troop.targetKey != 0)
{
TroopData tarTroop = battleData.mAllTroopDic[troop.targetKey];
if (tarTroop == null)
{
return(false);
}
uint atkDis = TroopHelper.GetTroopAtkDis(troop.type);
uint myRange = TroopHelper.GetTroopRange(troop.type);
uint tarRange = TroopHelper.GetTroopRange(tarTroop.type);
int dis = MathHelper.TroopDistanceV2(troop, tarTroop);
if (dis > atkDis + myRange + tarRange)
{
return(false);
}
else
{
return(true);
}
}
return(false);
}
protected override BTreeRunningStatus _DoExecute(BTreeTemplateData input, ref BTreeTemplateData output)
{
base._DoExecute(input, ref output);
BTreeInputData _input = input as BTreeInputData;
BTreeOutputData _output = output as BTreeOutputData;
if (_input == null || _output == null)
{
Debugger.LogError("数据类型错误");
}
var troop = _input.troop;
var outTroop = _output.troop;
var target = _input.battleData.mAllTroopDic[troop.targetKey];
var tar_x = target.x;
var tar_y = target.y;
outTroop.dir_x = tar_x;
outTroop.dir_y = tar_y;
outTroop.state = (int)TroopAnimState.Attack;
outTroop.inPrepose = true;
outTroop.preTime = TroopHelper.GetTroopAtkPrepareTime(outTroop.type);
outTroop.isAtk = true;
outTroop.norAtkCD = TroopHelper.GetTroopAtkCDTime(outTroop.type);
return(BTreeRunningStatus.Finish);
}
private void DoSoldierLogic()
{
for (int i = 0; i < m_AtkTroopList.Count; i++)
{
var _atkTroop = m_AtkTroopList[i];
m_Input.SetData(_atkTroop, m_BattleLogicMgr.m_BattleData);
m_Output.SetData(m_Input);
if (!m_TroopBTreeDic.ContainsKey(_atkTroop.key))
{
m_TroopBTreeDic.Add(_atkTroop.key, new BTreeRoot());
m_TroopBTreeDic[_atkTroop.key].CreateBevTree();
}
BTreeTemplateData _output = m_Output as BTreeTemplateData;
m_TroopBTreeDic[_atkTroop.key].Tick(m_Input, ref _output);
m_Output = _output as BTreeOutputData;
m_AtkTroopList[i] = m_Output.troop;
}
for (int i = 0; i < m_DefTroopList.Count; i++)
{
var _defTroop = m_DefTroopList[i];
m_Input.SetData(_defTroop, m_BattleLogicMgr.m_BattleData);
m_Output.SetData(m_Input);
if (!m_TroopBTreeDic.ContainsKey(_defTroop.key))
{
m_TroopBTreeDic.Add(_defTroop.key, new BTreeRoot());
m_TroopBTreeDic[_defTroop.key].CreateBevTree();
}
BTreeTemplateData _output = m_Output as BTreeTemplateData;
m_TroopBTreeDic[_defTroop.key].Tick(m_Input, ref _output);
m_Output = _output as BTreeOutputData;
m_DefTroopList[i] = m_Output.troop;
}
}
protected override BTreeRunningStatus _DoTick(BTreeTemplateData _input, ref BTreeTemplateData _output)
{
BTreeRunningStatus runningStatus = BTreeRunningStatus.Finish;
//First Time
if (m_CurrentNodeIndex == INVALID_CHILD_NODE_INDEX)
{
m_CurrentNodeIndex = 0;
}
BTreeNode bn = m_ChildNodes[m_CurrentNodeIndex];
runningStatus = bn.Tick(_input, ref _output);
if (runningStatus == BTreeRunningStatus.Finish)
{
m_CurrentNodeIndex++;
if (m_CurrentNodeIndex == m_ChildCount)
{
m_CurrentNodeIndex = INVALID_CHILD_NODE_INDEX;
}
else
{
runningStatus = BTreeRunningStatus.Executing;
}
}
if (runningStatus == BTreeRunningStatus.Error)
{
m_CurrentNodeIndex = INVALID_CHILD_NODE_INDEX;
}
return(runningStatus);
}
protected override void _DoTransition(BTreeTemplateData _input)
{
for (int i = 0; i < m_ChildCount; i++)
{
m_ChildNodeSatuses[i] = BTreeRunningStatus.Executing;
BTreeNode bn = m_ChildNodes[i];
bn.Transition(_input);
}
}
protected override void _DoTransition(BTreeTemplateData _input)
{
if (_CheckIndex(0))
{
BTreeNode bn = m_ChildNodes[0];
bn.Transition(_input);
}
m_CurrentCount = 0;
}
protected override void _DoTransition(BTreeTemplateData _input)
{
if (_CheckIndex(m_CurrentNodeIndex))
{
BTreeNode bn = m_ChildNodes[m_CurrentNodeIndex];
bn.Transition(_input);
}
m_CurrentNodeIndex = INVALID_CHILD_NODE_INDEX;
}
protected override void _DoTransition(BTreeTemplateData _input)
{
if (m_NeedExit)
{
_DoExit(_input, BTreeRunningStatus.Error);
}
SetActiveNode(null);
m_Status = BTreeNodeStatus.Ready;
m_NeedExit = false;
}
public override bool ExternalCondition(BTreeTemplateData _input)
{
for (int i = 0; i < m_Preconditions.Length; i++)
{
if (m_Preconditions[i].ExternalCondition(_input))
{
return(true);
}
}
return(false);
}
public void Tick(BTreeTemplateData _input, ref BTreeTemplateData _output)
{
if (m_TreeRoot.Evaluate(_input))
{
m_TreeRoot.Tick(_input, ref _output);
}
else
{
m_TreeRoot.Transition(_input);
}
}
protected override BTreeRunningStatus _DoExecute(BTreeTemplateData input, ref BTreeTemplateData output)
{
BTreeInputData _input = input as BTreeInputData;
BTreeOutputData _output = output as BTreeOutputData;
if (_input == null || _output == null)
{
Debugger.LogError("数据类型错误");
}
return(BTreeRunningStatus.Executing);
}
protected override bool _DoEvaluate(BTreeTemplateData _input)
{
if (_CheckIndex(m_CurrentSelectIndex))
{
BTreeNode bn = m_ChildNodes[m_CurrentSelectIndex];
if (bn.Evaluate(_input))
{
return(true);
}
}
return(base._DoEvaluate(_input));
}
public void Tick(BTreeTemplateData _input, ref BTreeTemplateData _output)
{
Debugger.Log_Btree("****************Tick_Begin****************");
if (m_TreeRoot.Evaluate(_input))
{
m_TreeRoot.Tick(_input, ref _output);
}
else
{
m_TreeRoot.Transition(_input);
}
Debugger.Log_Btree("****************Tick_End****************");
}
protected override bool _DoEvaluate(BTreeTemplateData _input)
{
for (int i = 0; i < m_ChildCount; i++)
{
BTreeNode bn = m_ChildNodes[i];
if (bn.Evaluate(_input))
{
m_CurrentSelectIndex = i;
return(true);
}
}
return(false);
}
protected override bool _DoEvaluate(BTreeTemplateData _input)
{
for (int i = 0; i < m_ChildCount; i++)
{
BTreeNode bn = m_ChildNodes[i];
if (m_ChildNodeSatuses[i] == BTreeRunningStatus.Executing)
{
if (!bn.Evaluate(_input))
{
return(false);
}
}
}
return(true);
}
protected override BTreeRunningStatus _DoExecute(BTreeTemplateData input, ref BTreeTemplateData output)
{
BTreeInputData _input = input as BTreeInputData;
BTreeOutputData _output = output as BTreeOutputData;
if (_input == null || _output == null)
{
Debugger.LogError("数据类型错误");
}
if (_input.troop.targetKey != 0)
{
_output.troop.state = (int)TroopAnimState.Move;
MoveToTarget(_input, ref _output);
}
return(BTreeRunningStatus.Finish);
}
public override bool ExternalCondition(BTreeTemplateData input)
{
var _input = (BTreeInputData)input;
var troop = _input.troop;
if (troop.targetKey != 0)
{
var target = _input.battleData.mAllTroopDic[troop.targetKey];
var dis = MathHelper.DistanceV2(troop.x, troop.y, target.x, target.y);
if (dis <= 0)
{
return(true);
}
}
return(false);
}
protected override BTreeRunningStatus _DoExecute(BTreeTemplateData input, ref BTreeTemplateData output)
{
base._DoExecute(input, ref output);
BTreeInputData _input = input as BTreeInputData;
BTreeOutputData _output = output as BTreeOutputData;
if (_input == null || _output == null)
{
Debugger.LogError("数据类型错误");
}
var troop = _input.troop;
var outTroop = _output.troop;
List <TroopData> enemys;
if (troop.isAtkTroop)
{
enemys = _input.battleData.mDefTroopList;
}
else
{
enemys = _input.battleData.mAtcTroopList;
}
//找最近的目标
int minDis = -1;
uint targetKey = 0;
for (int i = 0; i < enemys.Count; i++)
{
int dis = MathHelper.TroopDistanceV2(troop, enemys[i]);
if (minDis < 0)
{
minDis = dis;
targetKey = enemys[i].key;
}
else if (minDis > dis)
{
minDis = dis;
targetKey = enemys[i].key;
}
}
outTroop.targetKey = targetKey;
return(BTreeRunningStatus.Finish);
}
protected override bool _DoEvaluate(BTreeTemplateData _input)
{
bool checkLoopCount = m_LoopCount == INFINITELOOP || m_CurrentCount < m_LoopCount;
if (!checkLoopCount)
{
return(false);
}
if (_CheckIndex(0))
{
BTreeNode bn = m_ChildNodes[0];
if (bn.Evaluate(_input))
{
return(true);
}
}
return(false);
}
protected override BTreeRunningStatus _DoTick(BTreeTemplateData _input, ref BTreeTemplateData _output)
{
base._DoTick(_input, ref _output);
int finishedChildCount = 0;
for (int i = 0; i < m_ChildCount; i++)
{
BTreeNode bn = m_ChildNodes[i];
if (m_FinishCondition == BTreeParallelFinishCondition.OR)
{
if (m_ChildNodeSatuses[i] == BTreeRunningStatus.Executing)
{
m_ChildNodeSatuses[i] = bn.Tick(_input, ref _output);
}
if (m_ChildNodeSatuses[i] != BTreeRunningStatus.Executing)
{
_RestChildNodeStatus();
return(BTreeRunningStatus.Finish);
}
}
else if (m_FinishCondition == BTreeParallelFinishCondition.AND)
{
if (m_ChildNodeSatuses[i] == BTreeRunningStatus.Executing)
{
m_ChildNodeSatuses[i] = bn.Tick(_input, ref _output);
}
if (m_ChildNodeSatuses[i] != BTreeRunningStatus.Executing)
{
finishedChildCount++;
}
}
else
{
Debugger.LogError("BTreeParallelFinishCondition Error");
}
}
if (finishedChildCount == m_ChildCount)
{
_RestChildNodeStatus();
return(BTreeRunningStatus.Finish);
}
return(BTreeRunningStatus.Executing);
}
public override bool ExternalCondition(BTreeTemplateData input)
{
var _input = (BTreeInputData)input;
var troop = _input.troop;
if (troop.targetKey != 0)
{
if (_input.battleData.mAllTroopDic.ContainsKey(troop.targetKey))
{
var target = _input.battleData.mAllTroopDic[troop.targetKey];
if (target.count > 0)
{
return(true);
}
}
}
return(false);
}
protected override BTreeRunningStatus _DoExecute(BTreeTemplateData input, ref BTreeTemplateData output)
{
base._DoExecute(input, ref output);
BTreeInputData _input = input as BTreeInputData;
BTreeOutputData _output = output as BTreeOutputData;
if (_input == null || _output == null)
{
Debugger.LogError("数据类型错误");
}
var troop = _input.troop;
var outTroop = _output.troop;
if (troop.count == 0)
{
outTroop.state = (int)TroopAnimState.Die;
return(BTreeRunningStatus.Executing);
}
if (troop.inPrepose)
{
if (troop.preTime > 0)
{
outTroop.preTime = troop.preTime - 1;
}
else
{
outTroop.inPrepose = false;
}
outTroop.state = (int)TroopAnimState.Idle;
return(BTreeRunningStatus.Executing);
}
if (troop.norAtkCD > 0)
{
outTroop.norAtkCD = troop.norAtkCD - 1;
outTroop.state = (int)TroopAnimState.Idle;
return(BTreeRunningStatus.Executing);
}
outTroop.state = (int)TroopAnimState.Idle;
return(BTreeRunningStatus.Finish);
}
protected override bool _DoEvaluate(BTreeTemplateData _input)
{
int testNode;
if (m_CurrentNodeIndex == INVALID_CHILD_NODE_INDEX)
{
testNode = 0;
}
else
{
testNode = m_CurrentNodeIndex;
}
if (_CheckIndex(testNode))
{
BTreeNode bn = m_ChildNodes[testNode];
if (bn.Evaluate(_input))
{
return(true);
}
}
return(false);
}
public void Transition(BTreeTemplateData _input)
{
_DoTransition(_input);
}
public bool Evaluate(BTreeTemplateData _input)
{
return((m_NodePrecondition == null ||
m_NodePrecondition.ExternalCondition(_input)) &&
_DoEvaluate(_input));
}
protected virtual BTreeRunningStatus _DoTick(BTreeTemplateData _input, ref BTreeTemplateData _output)
{
return(BTreeRunningStatus.Finish);
}
protected virtual void _DoTransition(BTreeTemplateData _input)
{
return;
}
