protected ENodeState HandleDebug(ENodeState state)
{
lastReturn = state;
ticks++;
CountReturn(lastReturn);
return(lastReturn);
}
/*public override ENodeState OnBehaviour(Context data, bool handled)
* {
* int failed = 0,
* successed = 0;
*
* foreach (var child in children)
* {
* ENodeState status = child.Behaviour(data);
* if (status == ENodeState.FAILURE)
* failed++;
* else if (status == ENodeState.SUCCESS)
* successed++;
* }
*
* if (successed >= reqSuccess)
* return ENodeState.SUCCESS;
* else if (failed >= reqFail)
* return ENodeState.FAILURE;
*
* return ENodeState.RUNNING;
* }*/
public override ENodeState OnBehaviour(Context data)
{
if (IsAllChildrenExecuted())
{
return(ENodeState.FAILURE);
}
ENodeState current = GetCurrentChildState(data);
if (current == ENodeState.SUCCESS)
{
successed++;
}
else if (current == ENodeState.FAILURE)
{
failed++;
}
if (successed >= reqSuccess)
{
return(ENodeState.SUCCESS);
}
else if (failed >= reqFail)
{
return(ENodeState.FAILURE);
}
NextChild();
return(OnBehaviour(data));
}
/// <summary>
/// Method to recursively update the state of the nodes.
/// </summary>
/// <param name="state">Updated state</param>
public override void UpdateState(ENodeState state)
{
State.State = state;
foreach (string key in values.Keys)
{
values[key].UpdateState(state);
}
}
/// <summary>
/// Method to recursively update the state of the nodes.
/// </summary>
/// <param name="state">Updated state</param>
public override void UpdateState(ENodeState state)
{
State.State = state;
foreach (T value in values)
{
value.UpdateState(state);
}
}
/// <summary>
/// Method to recursively update the state of the nodes.
/// </summary>
/// <param name="state">Updated state</param>
public override void UpdateState(ENodeState state)
{
State.State = state;
if (Node != null)
{
Node.UpdateState(state);
}
}
protected void CountReturn(ENodeState state)
{
if (!returnCount.ContainsKey(state))
{
returnCount.Add(state, 0);
}
returnCount[state]++;
}
/// <summary>
/// Method to recursively update the state of the nodes.
/// </summary>
/// <param name="state">Updated state</param>
public override void UpdateState(ENodeState state)
{
State.State = state;
foreach (string key in children.Keys)
{
children[key].UpdateState(state);
}
}
public void Transition()
{
//logDebug("Transition");
if (null != _preCondition)
{
_preCondition.Transition();
}
onTransition();
_state = ENodeState.init;
}
public override ENodeState OnBehaviour(Context data)
{
ENodeState result = child.Behaviour(data);
if (result != ENodeState.RUNNING)
{
ResetHandle();
}
return(result == ENodeState.RUNNING ? ENodeState.RUNNING : ENodeState.SUCCESS);
}
public override ENodeState OnBehaviour(Context data)
{
ENodeState result = child.Behaviour(data);
if (result != ENodeState.RUNNING)
{
ResetHandle();
}
return(HandleDebug(result == ENodeState.FAILURE ? ENodeState.FAILURE : ENodeState.RUNNING));
}
protected virtual bool onEvaluate()
{
if (_preCondition != null && false == _preCondition.IsTrue())
{
_state = ENodeState.failed;
return(false);
}
else
{
_state = ENodeState.success;
return(true);
}
}
public static ENodeState Invert(ENodeState state)
{
if (state == ENodeState.FAILURE)
{
return(ENodeState.SUCCESS);
}
else if (state == ENodeState.SUCCESS)
{
return(ENodeState.FAILURE);
}
return(ENodeState.RUNNING);
}
public virtual void Reset()
{
Flag = ENodeState.unknown;
G = H = F = FP.MaxValue;
extraCost = FP.Zero;
NodeID = -1;
PreviousCount = 0;
Parent = null;
_heapIndex = -1;
if (children != null)
{
children.Clear();
}
pathId = -1;
}
public ENodeState Behaviour(Context data)
{
if (isFirstRun)
{
OnInit(data);
isFirstRun = false;
}
ENodeState state = OnBehaviour(data);
if (state != ENodeState.RUNNING)
{
ResetHandle();
}
return(state);
}
public override ENodeState OnBehaviour(Context data)
{
if (IsAllChildrenExecuted())
{
OnReset();
return(HandleDebug(ENodeState.RUNNING));
}
if (!childrenOver[currentChild])
{
ENodeState current = GetCurrentChildState(data);
HandleDebug(current);
if (current != ENodeState.RUNNING)
{
childrenOver[currentChild] = true;
}
if (current == ENodeState.SUCCESS)
{
successed++;
}
else if (current == ENodeState.FAILURE)
{
failed++;
}
if (successed >= reqSuccess)
{
return(ENodeState.SUCCESS);
}
else if (failed >= reqFail)
{
return(ENodeState.FAILURE);
}
NextChild();
return(OnBehaviour(data));
}
NextChild();
return(ENodeState.RUNNING);
}
void Awake()
{
nodeState = ENodeState.Ok;
nodeValue = new NodeValue(false);
ady = new NodeAdy[(int)EAdyDirection.Count];
for (int i = 0; i < ady.Length; i++)
{
ady[i].node = null;
if (i % 2 == 0)
{
ady[i].type = ENodeAdyType.Straight;
}
else
{
ady[i].type = ENodeAdyType.Diagonal;
}
}
}
public override ENodeState OnBehaviour(Context data)
{
if (IsAllChildrenExecuted())
{
return(ENodeState.SUCCESS);
}
ENodeState current = GetCurrentChildState(data);
if (current == ENodeState.SUCCESS)
{
NextChild();
return(OnBehaviour(data));
}
else if (current == ENodeState.FAILURE)
{
return(ENodeState.FAILURE);
}
return(ENodeState.RUNNING);
}
public GBTNode()
{
_state = ENodeState.init;
_parent = null;
}
// 更新节点
protected virtual ENodeState onUpdate()
{
_state = ENodeState.success;
return(_state);
}
/// <summary>
/// Method to recursively update the state of the nodes.
/// </summary>
/// <param name="state">Updated state</param>
public override void UpdateState(ENodeState state)
{
State.State = state;
}
// 节点退出清理
protected virtual void onTransition()
{
_state = ENodeState.init;
}
/// <summary> /// Method to recursively update the state of the nodes. /// </summary> /// <param name="state">Updated state</param> public abstract void UpdateState(ENodeState state);
public ENodeState Update()
{
logDebug("Update");
_state = onUpdate();
return(_state);
}
public override void UpdateState(ENodeState state)
{
throw new NotImplementedException();
}
public ENodeState GetCurrentChildState(Context data)
{
ENodeState ret = (GetCurrentChild() as Node).Behaviour(data);
return(ret);
}
