public static BTState TickNode(NodeBase node, float deltaTime)
{
if (node.nodeState == NodeState.Raw)
{
throw new Exception("Trying to tick a raw node!");
}
if (node.nodeState == NodeState.Visited)
{
throw new Exception("Trying to tick a visited node!");
}
// first time
if (node.nodeState == NodeState.Ready)
{
node.OnEnter();
node.nodeState = NodeState.Visiting;
}
// regular tick
BTState ret = node.Update(deltaTime);
if (ret == BTState.Running)
{
return(ret);
}
// last time
node.OnExit();
node.nodeState = NodeState.Visited;
return(ret);
}
public void OnFireEvent(BTState state, BTEvent btEvent)
{
//XLogger.Log( state.ToString(), state );
var currNode = FindBTNode(state);
currNode.FireEvent(btEvent);
}
public BTNode AddNewBTNode(BTState newBTState)
{
var newNode = new BTNode(newBTState);
totalNode.Add(newNode);
return(newNode);
}
// Update is called once per frame
void Update()
{
if (state == BTState.RUNNING)
{
state = EBUpdate();
}
}
public static void AddStateToFsm(BTFsm owner, BTState targetState)
{
if (BTEditorWindow.HasPrefab(owner))
{
if (owner.template == null)
{
AddTemplateToFsm(owner);
owner.template.startEvent = owner.startEvent;
owner.template.totalEvent = owner.totalEvent;
if (owner.template.totalState == null)
{
owner.template.totalState = new List <BTState>();
}
}
BTEditorWindow.AddObjectToAsset(targetState, owner.template);
owner.template.totalState.Add(targetState);
EditorUtility.SetDirty(owner);
}
else if (owner.template != null)
{
owner.template.totalState.Add(targetState);
BTEditorWindow.AddObjectToAsset(targetState, owner.template);
EditorUtility.SetDirty(owner.template);
}
}
internal static BTState NodeTick(NodeBase node, float deltaTime)
{
if (node.nodeState == NodeState.Raw)
{
throw new Exception("A raw node can not tick!");
}
if (node.nodeState == NodeState.Visited)
{
throw new Exception("A visited node can not tick!");
}
// first time
if (node.nodeState == NodeState.Ready)
{
node.OnEnter();
node.nodeState = NodeState.Visiting;
}
// regular tick
BTState ret = node.Update(deltaTime);
node.behaviorTree.logger.Debug(node.ToString() + " : " + ret);
if (ret == BTState.Running)
{
return(ret);
}
// last time
node.OnExit();
node.nodeState = NodeState.Visited;
return(ret);
}
public void ClickNode(object obj)
{
var className = obj as string;
var btNode = currNode as BTNode;
if (className == "NewEvent")
{
BTEvent.Create(btNode.BtState);
}
else if (className == "OpenScript")
{
btNode.OpenScript();
}
else if (className == "DeleteState")
{
DeleteCurrState();
}
else if (className == "CopyState")
{
copyState = btNode.BtState;
}
else
{
var type = Type.GetType(className);
if (type.IsSubclassOf(typeof(BTAction)))
{
var newAction = CreateAction(type, btNode.BtState);
newAction.OnCreate();
EditorUtility.SetDirty(newAction);
Debug.Log(type.ToString());
}
}
}
public sealed override BTState Tick()
{
if (this.current == -1)
{
this.current = target;
}
state = child.Tick();
if (state == BTState.Running)
{
return(BTState.Running);
}
else
{
if (this.current > 0)
{
this.current--;
return(BTState.Running);
}
else
{
this.current = -1;
return(state);
}
}
}
public override void OnPaste()
{
base.OnPaste();
List <BTState> newStates = new List <BTState>();
for (int i = 0; i < copiedStates.Count; i++)
{
var copyState = copiedStates[i];
var newState = BTState.Create(target, copyState);
newState.name = copyState.name;
newState.OnCreate();
BTEditorWindow.instance.AddNewBTNode(newState);
EditorUtility.SetDirty(target);
BTGenericMenu.AddStateToFsm(target, newState);
newStates.Add((newState));
}
for (int j = 0; j < newStates.Count; j++)
{
var newState = newStates[j];
newState.ReFindEvent();
for (int i = 0; i < newState.totalActions.Count; i++)
{
BTGenericMenu.AddActionToState(newState, newState.totalActions[i]);
}
}
EditorUtility.SetDirty(target);
ShowNotification(new GUIContent("Pasted {0} State.".Format(newStates.Count)));
}
public sealed override BTState Tick()
{
if (fn != null)
{
fn();
return(BTState.Success);
}
else
{
if (coroutine == null || this.bt.previousTick != this.tick)
{
coroutine = coroutineFactory();
}
this.tick = this.bt.currentTick;
if (!coroutine.MoveNext())
{
coroutine = null;
return(BTState.Success);
}
result = coroutine.Current;
if (result == BTState.Running)
{
return(BTState.Running);
}
else
{
coroutine = null;
return(result);
}
}
}
public override BTState Update()
{
BT selected;
if (lastContinue != null)
{
selected = lastContinue;
}
else
{
selected = child[UnityEngine.Random.Range(0, childSize - 1)];
}
BTState state = selected.Update();
if (state == BTState.CONTINUE)
{
lastContinue = selected;
}
else
{
lastContinue = null;
}
return(state);
}
//public static BTNode<T> CreateNode( T state )
//{
// var t = CreateInstance(typeof( BTNode<T> )) as BTNode<T>;
// if( typeof(T).GetCustomAttributes( typeof( StateTitleAttribute ), true ).Length > 0 )
// {
// t.isCustomState = true;
// }
// return t;
//}
public BTNode(BTState btState)
{
this.BtState = btState;
if (btState.GetType().GetCustomAttributes(typeof(StateTitleAttribute), true).Length > 0)
{
isCustomState = true;
}
}
public static BTAction CreateAction(Type type, BTState parentState)
{
BTAction action = XScriptableObject.CreateInstance(type) as BTAction;
action.Name = type.Name;
action.Owner = parentState;
parentState.totalActions.Add(action);
AddActionToState(parentState, action);
return(action);
}
public override void OnEnter()
{
base.OnEnter();
if (targetState != null)
{
targetState = Fsm.FindState(targetState);
}
targetState.Priority += Increment;
}
public BTNode FindBTNode(BTState currNode)
{
for (int i = 0; i < totalNode.Count; i++)
{
if (totalNode[i].BtState == currNode)
{
return(totalNode[i]);
}
}
return(null);
}
public static BTState Invert(this BTState state)
{
if (state == BTState.Fail)
{
return(BTState.Completed);
}
if (state == BTState.Completed)
{
return(BTState.Fail);
}
return(state);
}
public override BTState Update()
{
lastState = BTState.FAILURE; //처음에 끝나는거 방지
if (condition())
{
lastState = child.Update();
return(BTState.CONTINUE);
}
else
{
return(lastState);
}
}
public sealed override BTState Tick(BTState overrideState)
{
for (int i = this.children.Count - 1; i >= 0; i--)
{
this.index = this.remaining[i];
this.childState = this.children[this.index].Tick();
switch (this.childState)
{
case BTState.Success:
this.numberOfSuccess++;
this.remaining.Remove(this.index);
if (this.remaining.Count == 0)
{
if (this.numberOfSuccess == this.children.Count)
{
return(BTState.Success);
}
else
{
return(BTState.Failure);
}
}
break;
case BTState.Failure:
this.remaining.Remove(this.index);
if (this.remaining.Count == 0)
{
if (this.numberOfSuccess == this.children.Count)
{
return(BTState.Success);
}
else
{
return(BTState.Failure);
}
}
break;
case BTState.Running:
break;
default:
return(BTState.Failure);
}
}
this.bt.currentRunningNode = this;
return(BTState.Running);
}
private BTState Invert(BTState state)
{
switch (state)
{
case BTState.Failure:
return(BTState.Success);
case BTState.Success:
return(BTState.Failure);
default:
return(BTState.Running);
}
}
void AddCustomState(object obj)
{
var para = obj as string;
var type = Type.GetType(para);
var newState = BTState.Create(currFsm, type);
newState.Name = type.Name;
var newNode = BTEditorWindow.instance.AddNewBTNode(newState);
newState.OnCreate();
newNode.SetPosition(BTEditorWindow.instance.GetMousePosition());
EditorUtility.SetDirty(currFsm);
AddStateToFsm(currFsm, newState);
}
public static void AddActionToState(BTState Owner, BTAction action)
{
var Fsm = Owner.Owner;
if (BTEditorWindow.HasPrefab(Fsm))
{
if (Fsm.template == null)
{
AddTemplateToFsm(Fsm);
Fsm.template.startEvent = Fsm.startEvent;
Fsm.template.totalEvent = Fsm.totalEvent;
}
BTEditorWindow.AddObjectToAsset(action, Owner);
}
EditorUtility.SetDirty(Fsm);
}
public override BTState Update()
{
for (int i = 0; i < childSize; i++)
{
BTState state = child[i].Update();
if (state == BTState.SUCCESS)
{
continue;
}
else
{
return(state);
}
}
return(BTState.FAILURE);
}
public override BTState Update()
{
BTState state = BTState.FAILURE;
if (isFinish && UnityEngine.Random.Range(0f, 1f) <= probability)
{
isFinish = false;
}
if (!isFinish)
{
state = child.Update();
if (state != BTState.CONTINUE)
{
isFinish = true;
}
}
return(state);
}
public static void AddActionToState(BTState Owner, BTAction action)
{
var Fsm = Owner.Owner;
if (BTEditorWindow.HasPrefab(Fsm))
{
if (Fsm.template == null)
{
Fsm.template = XScriptableObject.CreateInstance <BTTemplate> ();
BTEditorWindow.AddObjectToAsset(Fsm.template, Fsm.gameObject);
EditorUtility.SetDirty(Fsm);
Fsm.template.startEvent = Fsm.startEvent;
Fsm.template.totalEvent = Fsm.totalEvent;
}
BTEditorWindow.AddObjectToAsset(action, Owner);
}
EditorUtility.SetDirty(Fsm);
}
public sealed override BTState Tick(BTState overrideState)
{
switch (this.CheckCondition())
{
case BTState.Success:
break;
case BTState.Failure:
return(BTState.Failure);
case BTState.Running:
return(BTState.Running);
}
this.childState = (overrideState == BTState.None) ? this.children[this.activeChild].Tick() : overrideState;
switch (this.childState)
{
case BTState.Success:
this.activeChild++;
if (this.activeChild == this.children.Count)
{
this.activeChild = 0;
return(BTState.Success);
}
else
{
this.bt.currentRunningNode = this;
return(BTState.Running);
}
case BTState.Running:
this.bt.currentRunningNode = this.children[this.activeChild];
return(BTState.Running);
case BTState.Failure:
this.activeChild = 0;
return(BTState.Failure);
default:
return(BTState.Failure);
}
}
public void Tick(float deltaTime)
{
if (!isRunning)
{
return;
}
BTState ret = NodeBase.TickNode(root, deltaTime);
if (ret != BTState.Running)
{
isRunning = false;
if (OnBehaviorTreeCompleted != null)
{
OnBehaviorTreeCompleted.Invoke(this, ret);
}
}
logger.Debug("tree ret = " + ret);
}
public Mapper(BTState child, bool trueValue, bool falseValue)
{
f_childState = child;
if (trueValue)
{
f_trueValue = BTStateReturn.True;
}
else
{
f_trueValue = BTStateReturn.False;
}
if (falseValue)
{
f_falseValue = BTStateReturn.True;
}
else
{
f_falseValue = BTStateReturn.False;
}
}
public virtual BTState Tick(BTState overrideState)
{
Debug.LogWarning("Should have redefined this 'Tick' !");
return(BTState.Failure);
}
public BehaviourTree(BTState root)
{
f_root = root;
}
public void ClickNone(object obj)
{
var para = obj as string;
switch (para)
{
case "NewGlobalEvent":
{
var newEvent = BTEvent.Create(currFsm);
var newState = BTState.Create <BTState>(currFsm);
newEvent.TargetState = newState;
newState.GlobalEvent = newEvent;
BTEditorWindow.instance.AddNewBTNode(newState);
AddStateToFsm(currFsm, newState);
}
break;
case "NewState":
{
var newState = BTState.Create <BTState>(currFsm);
newState.Name = "NewState";
var newNode = BTEditorWindow.instance.AddNewBTNode(newState);
newNode.SetPosition(BTEditorWindow.instance.GetMousePosition());
EditorUtility.SetDirty(currFsm);
AddStateToFsm(currFsm, newState);
}
break;
case "PasteState":
{
var newState = BTState.Create(currFsm, copyState);
newState.Name = "NewState";
newState.OnCreate();
BTEditorWindow.instance.AddNewBTNode(newState);
EditorUtility.SetDirty(currFsm);
AddStateToFsm(currFsm, newState);
for (int i = 0; i < newState.totalActions.Count; i++)
{
AddActionToState(newState, newState.totalActions[i]);
}
}
break;
case "CancelEditFsm":
BTEditorWindow.target = null;
break;
default:
{
var type = Type.GetType(para);
if (type.IsSubclassOf(typeof(BTVariable)))
{
var newVariable = CreateVariable(type, currFsm);
newVariable.OnCreate();
EditorUtility.SetDirty(newVariable);
Debug.Log(type.ToString());
}
}
break;
}
}
