void OnMouseDown()
{
GameObject go = GameObject.Find("Updater");
otherScript = go.GetComponent<BehaviorTree>();
if (isSelected) {
Debug.Log ("Goodbye " + this.gameObject.name);
isSelected = false;
} else {
//Debug.Log ("Hello " + this.gameObject.name);
//string name = this.gameObject.name;
otherScript.changeSelection(this.gameObject);
isSelected = true;
}
}
public override IEnumerator Process(BehaviorTree tree)
{
mReturnValue = BehaviorReturn.Failure;
BehaviorVariable stackVar = tree.GetVariable(mStack);
if (stackVar != null)
{
//get required propetys/funcs
PropertyInfo countProp = stackVar.Variable.GetType().GetProperty("Count");
MethodInfo methodInfo = stackVar.Variable.GetType().GetMethod("Pop");
if(countProp != null && methodInfo != null)
{
int count = (int)countProp.GetValue(stackVar.Variable,null);
if(count > 0)
{
object ret = methodInfo.Invoke(stackVar.Variable, null);
if (ret != null)
{
tree.AddVariable(new BehaviorVariable(mID, ret));
mReturnValue = BehaviorReturn.Success;
}
}
}
}
yield return null;
}
public void Restart()
{
// Init BB
m_Blackboard = new Blackboard();
m_Blackboard.Trans = transform;
m_Blackboard.Player = GameObject.FindGameObjectWithTag("Player").transform;
m_Blackboard.Destination = transform.position + new Vector3(10, 0, 5);
m_Bt = new BehaviorTree();
m_Bt.m_Blackboard = m_Blackboard;
// Init tree
Repeat repeat = new Repeat(ref m_Bt, -1);
Sequence randomMove = new Sequence(ref m_Bt);
PickRandomTarget pickTarget = new PickRandomTarget();
MoveToPoint moveBehavior = new MoveToPoint();
randomMove.m_Children.Add(moveBehavior);
randomMove.m_Children.Add(pickTarget);
// Try out Chase behavior
m_Chase = new Chase(moveBehavior, m_Bt);
m_Flee = new Flee(moveBehavior, m_Bt);
repeat.m_Child = randomMove;
m_Bt.Start(repeat, this.SequenceComplete);
}
// Use this for initialization
void Start()
{
tree = GetComponent<BehaviorTree> ();
hasEnemy = (SharedBool)tree.GetVariable ("hasEnemy");
enemy = (SharedGameObject)tree.GetVariable ("enemy");
hp = (SharedFloat)tree.GetVariable ("hp");
}
public override IEnumerator Process(BehaviorTree tree)
{
yield return tree.BeginNode(mChild);
//invert the child node
mReturnValue = mChild.mReturnValue == BehaviorReturn.Success ? BehaviorReturn.Failure : BehaviorReturn.Success;
}
public override IEnumerator Process(BehaviorTree tree)
{
yield return tree.BeginNode(mChild);
//returns success whatever
mReturnValue = BehaviorReturn.Success;
}
public override IEnumerator Process(BehaviorTree tree)
{
GameObject[] poiObjects = GameObject.FindGameObjectsWithTag("POI");
if (poiObjects != null && poiObjects.Length > 0)
{
//the stack
Stack<GameObject> pois = new Stack<GameObject>();
//sort by distance
System.Array.Sort<GameObject>(poiObjects, delegate(GameObject c2, GameObject c1)
{
return Vector3.Distance(tree.transform.position, c1.transform.position).CompareTo
((Vector3.Distance(tree.transform.position, c2.transform.position)));
});
foreach (GameObject go in poiObjects)
pois.Push(go);
tree.AddVariable(new BehaviorVariable(mStackName, pois));
mReturnValue = BehaviorReturn.Success;
}
else
mReturnValue = BehaviorReturn.Failure;
yield return null;
}
public void Calling_Configure_after_calling_Update_throws()
{
var tree = new BehaviorTree();
tree.Configure().Condition(() => true);
tree.Update();
tree.Configure().Condition(() => true);
}
public override void OnStart()
{
GetComponent<Animator> ().Play ("hurt");
animator = GetComponent<Animator> ();
tree = GetComponent<BehaviorTree> ();
hurted = (SharedBool)tree.GetVariable ("hurted");
}
// Use this for initialization
void Awake()
{
// This is where we build the tree
BTNode root = new BTPrioritySelector();
bt = new BehaviorTree(root);
// Should we transform?
// Decorator to make sure this never wins the priority selection
BTNode transformCheckDec = root.AddChild(new BTDecAlwaysFail());
// Do the actual check
transformCheckDec.AddChild(new BTAction(delegate(){
if (state == PlayerState.Normal && Input.GetKeyDown(KeyCode.Space)) {
BecomeHulk();
}
return BTStatusCode.Success;
}));
// Normal sequence
BTNode normalSeq = root.AddChild(new BTSequence());
// Are we in Normal mode?
normalSeq.AddChild(new BTCondition(delegate(){ return state == PlayerState.Normal; })); // Anonymous methods are great for this!
// Get input
normalSeq.AddChild(new BTAction(GetInput));
// Move player
normalSeq.AddChild(new BTAction(NormalMove));
// Hulk sequence
BTNode hulkSeq = root.AddChild(new BTSequence());
// Assume we're in hulk mode if we're here
// Get input
hulkSeq.AddChild(new BTAction(GetInput)); // New instance b/c each instance has it own status
// Move player
hulkSeq.AddChild(new BTAction(HulkMove));
}
public void Serialize(BehaviorTree behaviorTree)
{
// XML Document
XmlDocument doc = new XmlDocument();
// Behavior Tree
XmlElement btEl = doc.CreateElement("behaviortree");
doc.AppendChild(btEl);
// Root SubTree
SerializeSubTree (behaviorTree.rootNode, btEl);
// Unparented nodes root
XmlElement unparentedEl = doc.CreateElement("unparented");
btEl.AppendChild(unparentedEl);
// Unparented nodes
for (int i = 0; i < behaviorTree.nodes.Count; i++) {
if (behaviorTree.nodes[i].parent == null && !(behaviorTree.nodes[i] is Root)) {
SerializeSubTree(behaviorTree.nodes[i], unparentedEl);
}
}
serializedBehaviorTree = doc.InnerXml;
}
public override void OnStart()
{
animator = GetComponent<Animator> ();
animator.Play ("attack");
tree = GetComponent<BehaviorTree> ();
SharedGameObject enemy = (SharedGameObject)tree.GetVariable ("enemy");
transform.LookAt (enemy.Value.transform.position);
}
public void Can_call_Update_on_tree_with_single_action()
{
var actionWasCalled = false;
var tree = new BehaviorTree();
tree.Configure().Action(() => actionWasCalled = true);
tree.Update();
Assert.That(actionWasCalled, Is.True);
}
public void DrawBehaviorTree(BehaviorTree behaviorTree)
{
if(behaviorTree == null || BehaviorTreeEditor.BTEditorWindow == null)
{
return;
}
if(behaviorTree != _behaviorTree)
{
BehaviorTreeEditorHelper.GenerateQueue(_drawingQueue, behaviorTree);
BehaviorTreeEditor.BTEditorWindow.Repaint();
}
_behaviorTree = behaviorTree;
if (_behaviorTree.Child == null)
{
int i = EditorGUI.Popup(_addRootRect, "Add root: ", 0, _addChildOptions, BehaviorTreeEditorSettings.Instance.AddButtonStyle);
switch (i)
{
case 1:
Sequence newSequence = new Sequence();
behaviorTree.AddChild(newSequence);
break;
case 2:
Selector newSelector = new Selector();
behaviorTree.AddChild(newSelector);
break;
case 3:
Decorator newDecorator = new Decorator();
behaviorTree.AddChild(newDecorator);
break;
case 4:
Task t = new Task();
behaviorTree.AddChild(t);
break;
default:
break;
}
BehaviorTreeEditorHelper.GenerateQueue(_drawingQueue, _behaviorTree);
}
_scrollPos = GUI.BeginScrollView(new Rect(0, 100, BehaviorTreeEditor.BTEditorWindow.position.width - BehaviorTreeEditorSettings.Instance.SideMenuRect.width - 10, BehaviorTreeEditor.BTEditorWindow.position.height - _addRootRect.height - 100),
_scrollPos,
new Rect(0, 100, BehaviorTreeEditorHelper.GetWidth() * (BehaviorTreeEditorSettings.Instance.ElementWidth + BehaviorTreeEditorSettings.Instance.HorizontalSpaceBetweenElements) + 110 + _infoRect.x,
BehaviorTreeEditorHelper.GetDepth(_drawingQueue) * (BehaviorTreeEditorSettings.Instance.ElementHeight + BehaviorTreeEditorSettings.Instance.VerticalSpaceBetweenElements) + 100));
BehaviorTreeEditor.BTEditorWindow.BeginWindows();
GUILayout.Window(-1, _infoRect, DrawInfo, "Behavior Tree Info");
DrawStack();
BehaviorTreeEditor.BTEditorWindow.EndWindows();
GUI.EndScrollView();
}
private int mLoopCount = 0; /**< Number of times to loop the repeater */
public override IEnumerator Process(BehaviorTree tree)
{
for (int i = 0; i < mLoopCount; i++)
{
yield return tree.BeginNode(mChild);
}
mReturnValue = BehaviorReturn.Success;
}
public override IEnumerator Process(BehaviorTree tree)
{
//if it doesnt exist then its null?
mReturnValue = BehaviorReturn.Success;
BehaviorVariable var = tree.GetVariable(mObject);
if(var != null)
mReturnValue = var.Variable != null ? BehaviorReturn.Failure : BehaviorReturn.Success;
yield return null;
}
public void RunTest1()
{
MockBehavior mockBehavior = new MockBehavior();
BehaviorTree bt = new BehaviorTree();
bt.Start(mockBehavior);
CheckIntEqual(0, mockBehavior.m_InitializeCalled, "Init test");
bt.Tick();
CheckIntEqual(1, mockBehavior.m_InitializeCalled, "Single tick");
}
public static void Check(BehaviorTree bt)
{
_isChanged = false;
for (int i = 0; i < bt.nodes.Length; i++)
CheckNode(bt.nodes[i]);
if (_isChanged)
{
AssetDatabase.SaveAssets();
Debug.Log("changed");
}
}
private void SelectBehaviorBrainMenu(BehaviorTree bt, ref GenericMenu menu)
{
if (bt != null)
{
GUIContent content = new GUIContent(bt.name);
menu.AddItem(content, false, delegate ()
{
BehaviorTreeEditor.SelectBehaviorTrees(bt);
});
}
}
public override IEnumerator Process(BehaviorTree tree)
{
mReturnValue = BehaviorReturn.Failure;
NPC npc = tree.GetComponent<NPC>();
if(npc)
{
npc.DropItems();
mReturnValue = BehaviorReturn.Success;
}
yield return null;
}
public override IEnumerator Process(BehaviorTree tree)
{
mReturnValue = BehaviorReturn.Failure;
if(poiPrefab)
{
Object.Instantiate(poiPrefab);
mReturnValue = BehaviorReturn.Success;
}
yield return null;
}
public override IEnumerator Process(BehaviorTree tree)
{
mReturnValue = BehaviorReturn.Failure;
if(mVar != null && !string.IsNullOrEmpty(mID))
{
tree.AddVariable(new BehaviorVariable(mID, mVar));
mReturnValue = BehaviorReturn.Success;
}
yield return null;
}
public void Can_call_Update_on_tree_with_single_condition()
{
var conditionWasCalled = false;
var tree = new BehaviorTree();
tree.Configure().Condition(() =>
{
conditionWasCalled = true;
return false;
});
tree.Update();
Assert.That(conditionWasCalled, Is.True);
}
public void RunTest2()
{
MockBehavior t = new MockBehavior();
BehaviorTree bt = new BehaviorTree();
BehaviorObserver del = DelegateHandler;
bt.Start(t, del);
bt.Tick();
CheckIntEqual(1, t.m_UpdateCalled, "Single tick");
t.m_ReturnStatus = Status.BH_SUCCESS;
bt.Tick();
CheckIntEqual(2, t.m_UpdateCalled, "2nd tick return success");
}
public void RunTest3()
{
MockBehavior t = new MockBehavior();
BehaviorTree bt = new BehaviorTree();
BehaviorObserver del = DelegateHandler;
bt.Start(t, del);
bt.Tick();
CheckIntEqual(0, t.m_TerminateCalled, "1st terminate called");
t.m_ReturnStatus = Status.BH_SUCCESS;
bt.Tick();
CheckIntEqual(1, t.m_TerminateCalled, "2nd terminate called");
}
public void Condition_returning_false_stops_sequence()
{
var tree = new BehaviorTree();
tree.Configure().BeginSequence()
.Action(() => true)
.Condition(() => false)
.Action(() =>
{
Assert.Fail();
return true;
})
.End();
tree.Update();
}
public override IEnumerator Process(BehaviorTree tree)
{
mReturnValue = BehaviorReturn.Failure;
NPC npc = tree.GetComponent<NPC>();
if(npc)
{
if (npc.AvailableSlots > 0)
mReturnValue = BehaviorReturn.Success;
}
yield return null;
}
public override IEnumerator Process(BehaviorTree tree)
{
if (mChild != null)
{
do
{
yield return tree.BeginNode(mChild);
} while (mChild.mReturnValue != BehaviorReturn.Failure);
}
else
yield return null;
mReturnValue = BehaviorReturn.Success;
}
public override IEnumerator Process(BehaviorTree tree)
{
mReturnValue = BehaviorReturn.Failure;
BehaviorVariable poiVar = tree.GetVariable(mPOI);
GameObject poiObject = poiVar != null ? poiVar.Variable as GameObject : null;
NPC npc = tree.GetComponent<NPC>();
if(npc && poiObject)
{
if (npc.PickupItem(poiObject.transform))
mReturnValue = BehaviorReturn.Success;
}
yield return null;
}
void Awake()
{
_animator = GetComponent<Animator>();
_audio = GetComponent<AudioSource>();
_behaviorTree = GetComponent<BehaviorTree>();
_behaviorTree.PauseWhenDisabled = false;
_navMeshAgent = GetComponent<NavMeshAgent>();
_health = _maxHealth;
_baseAlerted = _alerted;
_baseSleeping = _sleeping;
_startingPosition = transform.position;
_startingRotation = transform.rotation;
if (GameManager.Instance.IsDead(_startingPosition))
GameObject.Destroy(gameObject);
}
protected override bool Run(BehaviorTree behaviorTree, BTEnv env)
{
// object a = env.Get<object>(this.Key);
//Log.Debug($"env : {JsonHelper.ToJson(a)}");
return(true);
}
public void Selector_returns_running_with_one_running_child()
{
var sequence = Selector.Node(Mocks.AlwaysRunningNode);
BehaviorTree.Run(sequence, Mocks.EmptyDictionary).ShouldEqual(NodeStatus.Running);
}
public BTTask_Attack(BehaviorTree <T> aBehaviorTree, float aAttackTime = 0) : base(aBehaviorTree)
{
mAttackTime = aAttackTime;
}
public override void SaveDataRecursive(BehaviorTree tree, SaveTreeGraphNodeAsset nodeAssetSaver)
{
SaveDataToAINode(tree, nodeAssetSaver);
}
public void Start()
{
mAILerp = GetComponent <AILerp>();
mBehaviorTree = GetComponent <BehaviorTree>();
Status = WorkerStatusEnum.IDLE;
}
public BTCond_HealthThreshold(BehaviorTree <T> aBehaviorTree, float aHealthThreshold) : this(aBehaviorTree) {
HealthThreshold = aHealthThreshold;
}
protected override void Awake()
{
behavior = GetComponent <BehaviorTree>();
base.Awake();
}
public BTTask_AimAt(BehaviorTree <T> aBehaviorTree) : base(aBehaviorTree)
{
}
public override void OnAwake()
{
_startPos = GetComponent <BossAtkAndDmg>().StartPoint;
_selfTree = GetComponent <BehaviorTree>();
_selfTree.SetVariableValue("seed", Random.Range(0, 10));
}
public BTTask_AimAt(BehaviorTree <T> aBehaviorTree, Transform aTarget, float aSmoothing = 0, float aMaxAngle = 0) : this(aBehaviorTree) {
mTarget = aTarget;
mLerpTarget = 1 - aSmoothing;
mMaxAngle = aMaxAngle;
}
protected override bool Run(BehaviorTree behaviorTree, BTEnv env)
{
//GuideComponent.Instance.RemoveEffect(Name);
return(true);
}
public BTCond_HealthThreshold(BehaviorTree <T> aBehaviorTree) : base(aBehaviorTree)
{
}
public void Selector_returns_success_with_one_succeeding_child()
{
var sequence = Selector.Node(Mocks.AlwaysSucceedsNode);
BehaviorTree.Run(sequence, Mocks.EmptyDictionary).ShouldEqual(NodeStatus.Success);
}
public void Selector_returns_failure_with_one_failing_child()
{
var sequence = Selector.Node(Mocks.AlwaysFailsNode);
BehaviorTree.Run(sequence, Mocks.EmptyDictionary).ShouldEqual(NodeStatus.Failure);
}
public void Init()
{
behaviorTree = Create();
behaviorTree.Execute();
}
protected override bool Run(BehaviorTree behaviorTree, BTEnv env)
{
//Game.EventSystem.Run(EventIdType.ShowGuidePanel, state);
return(true);
}
public BTCond_CanSee(BehaviorTree <T> aBehaviorTree, GameObject aTarget = null) : base(aBehaviorTree)
{
mTarget = aTarget;
}
public BTTask_MoveTowards(BehaviorTree <T> aBehaviorTree, Transform aTarget = null, bool aCanJump = true) : base(aBehaviorTree)
{
mTarget = aTarget;
mCanJump = aCanJump;
}
protected override bool Run(BehaviorTree behaviorTree, BTEnv env)
{
//Unit unit = env.Get<Unit>(UnitName);
//return unit.GetConfig<UnitMonoConfig>().Id == UnitID;
return(true);
}
public override void Start()
{
foodTarget = Vector3.zero;
animator = this.GetComponent <Animator>();
renderer = this.GetComponent <SpriteRenderer>();
float randTint = Random.Range(0, 230);
renderer.color = new Color((255 - randTint + 70) / 255f, (255 - randTint + 35) / 255f, (255 - randTint) / 255f);
speedMod = 3f;
moveSpeed = 0.05f;
// create behavior tree
tree = new BehaviorTree(
new Selector(new List <BehaviorComponent>()
{
// attack if close to bunny
new BehaviorAction(() => {
GameObject bunny = null;
GameObject[] bunnies = GameObject.FindGameObjectsWithTag("Bunny");
foreach (GameObject b in bunnies)
{
if (Vector3.Distance(
transform.position,
b.transform.position
) < listenDist)
{
bunny = b;
}
}
// if bunny is very close
if (bunny != null &&
Vector3.Distance(transform.position, bunny.transform.position)
<= attackDist)
{
Vector3 target = TargetGameObject(bunny);
// lunge every so often
if (Time.time - lastLungeTime >= lungeInterval)
{
speed = new Vector3(target.x * attackSpeed, target.y * attackSpeed);
lastLungeTime = Time.time;
}
return(BehaviorState.SUCCESS);
}
// bunny is not as close, hunt Mister Bunny
else if (bunny != null)
{
Vector3 target = TargetGameObject(bunny);
// move quickly towards bunny
speed = new Vector3(target.x * huntSpeed, target.y * huntSpeed);
return(BehaviorState.SUCCESS);
}
else
{
return(BehaviorState.FAILURE);
}
}),
// attack if too close to player
new BehaviorAction(() => {
GameObject player = GameObject.FindGameObjectsWithTag("Player")[0];
if (Vector3.Distance(
transform.position,
player.transform.position
) < attackDist)
{
Vector3 target = TargetGameObject(player);
// lunge every so often
if (Time.time - lastLungeTime >= lungeInterval)
{
speed = new Vector3(target.x * attackSpeed, target.y * attackSpeed);
lastLungeTime = Time.time;
}
return(BehaviorState.SUCCESS);
}
else
{
return(BehaviorState.FAILURE);
}
}),
// slow down and stalk player
new BehaviorAction(() => {
if (Vector3.Distance(
transform.position,
GameObject.FindGameObjectsWithTag("Player")[0].transform.position
) < listenDist)
{
GameObject player = GameObject.FindGameObjectsWithTag("Player")[0];
Vector3 target = TargetGameObject(player);
speed = new Vector3(target.x * moveSpeed / 2, target.y * moveSpeed / 2);
// TODO: growl
return(BehaviorState.SUCCESS);
}
else
{
return(BehaviorState.FAILURE);
}
}),
// eat nearby food
new BehaviorAction(() => {
if (foodTarget != Vector3.zero)
{
TargetFood();
return(BehaviorState.SUCCESS);
}
else
{
return(BehaviorState.FAILURE);
}
}),
// wander
new BehaviorAction(() => {
Wander();
return(BehaviorState.SUCCESS);
})
})
);
}
public BTStepSequencer(BehaviorTree t, BTNode[] children) : base(t, children)
{
}
public void Selector_returns_failure_with_zero_children()
{
var sequence = Selector.Node();
BehaviorTree.Run(sequence, Mocks.EmptyDictionary).ShouldEqual(NodeStatus.Failure);
}
void AttachAI(ServerNPC npc, int ai)
{
ServerLifeNpc lifeNpc = npc as ServerLifeNpc;
if (lifeNpc == null)
{
return;
}
lifeNpc.data.btData = new NPCBattleData();
lifeNpc.data.btData.way = BATTLE_WAY.None;
AILoader AiLoader = Core.ResEng.getLoader <AILoader>();
NPCAIType type = (NPCAIType)ai;
switch (type)
{
case NPCAIType.Pathfind_Atk:
{
BehaviorTree tree = npc.gameObject.GetComponent <BehaviorTree> ();
if (tree == null)
{
tree = npc.gameObject.AddComponent <BehaviorTree>();
}
tree.ExternalBehavior = AiLoader.load(AILoader.PATHFIND_ATK);
tree.StartWhenEnabled = true;
tree.RestartWhenComplete = true;
lifeNpc.AutoAiTree = tree;
}
break;
case NPCAIType.Simple_PfAtk:
{
BehaviorTree tree = npc.gameObject.GetComponent <BehaviorTree> ();
if (tree == null)
{
tree = npc.gameObject.AddComponent <BehaviorTree>();
}
tree.ExternalBehavior = AiLoader.load(AILoader.SIMPLE_PFATK);
tree.StartWhenEnabled = true;
tree.RestartWhenComplete = true;
lifeNpc.AutoAiTree = tree;
}
break;
case NPCAIType.Patrol:
{
BehaviorTree tree = npc.gameObject.GetComponent <BehaviorTree> ();
if (tree == null)
{
tree = npc.gameObject.AddComponent <BehaviorTree>();
}
tree.ExternalBehavior = AiLoader.load(AILoader.NORMAL_ATTACK);
tree.StartWhenEnabled = true;
tree.RestartWhenComplete = true;
lifeNpc.AutoAiTree = tree;
}
break;
}
}
public BTTask_Sprint(BehaviorTree <T> aBehaviorTree, bool aEnableSprint = true) : base(aBehaviorTree)
{
mEnableSprint = aEnableSprint;
}
protected override bool Run(BehaviorTree behaviorTree, BTEnv env)
{
return(true);
}
public override int Act(BehaviorTree tree)
{
Alert.see(time);
return(1);
}
public override void Init(BehaviorTree bt)
{
base.Init(bt);
child.Init(bt);
}
public override void Init(BehaviorTree bt)
{
base.Init(bt);
botTransform = ((PatrollerAndAttack)bt.Data["Bot"]).transform;
speed = ((PatrollerAndAttack)bt.Data["Bot"]).Speed;
}
public virtual void Init(BehaviorTree bt)
{
this.bt = bt;
}
protected MultiChildNode(BehaviorTree tree, Node parent)
: base(tree, parent)
{
}
