private void OnPlayModeStateChanged(PlayModeStateChange state)
{
switch (state)
{
case PlayModeStateChange.ExitingEditMode:
BehaviorTreeManager btManager = FindObjectOfType <BehaviorTreeManager>();
if (btManager != null && btManager.references != null && !btManager.references.ContainsKey(guid))
{
btManager.references[guid] = gameObjectVariable;
}
break;
case PlayModeStateChange.EnteredPlayMode:
var manager = FindObjectOfType <BehaviorTreeManager>();
if (manager != null && manager.references != null && manager.references.ContainsKey(guid))
{
gameObjectVariable = manager.references[guid];
}
break;
case PlayModeStateChange.EnteredEditMode:
break;
}
}
public override NodeState Evaluate()
{
i = 0;
while (i < nodes.Count)
{
if (nodes[i].isPhysicsBased & !BehaviorTreeManager.IsFixedTime())
{
return(SetState(NodeState.RUNNING));
}
NodeState status = nodes[i].Evaluate();
if (status.Equals(NodeState.SUCCESS))
{
// The current node was a success, lets continue to the next.
i++;
}
else// if(status.Equals(NodeState.FAILURE) || status.Equals(NodeState.RUNNING))
{
// Keep current index and stop the loop with the current status.
return(SetState(status));
}
}
// If this code path is reached, then all nodes where a success.
return(SetState(NodeState.SUCCESS));
}
public void TestInvalidVariable()
{
var treeManagerOwner = new BehaviorTreeManagerOwner();
var treeManager = new BehaviorTreeManager(treeManagerOwner);
var treeOwner = new BehaviorTreeOwner();
var tree = treeManager.CreateTree(treeOwner, "ConditionEvaluator1", null);
while (tree.RootTask.LastResult == TaskResult.Running)
{
tree.Update();
treeOwner.Tick(100);
}
}
private void OnEnable()
{
EditorApplication.playModeStateChanged += OnPlayModeStateChanged;
BehaviorTreeManager manager = FindObjectOfType <BehaviorTreeManager>();
if (manager != null && manager.references != null && guid != null)
{
if (manager.references.ContainsKey(guid))
{
gameObjectVariable = manager.references[this.guid];
}
}
}
public static void RunBehaviorTree(string path)
{
var treeManagerOwner = new BehaviorTreeManagerOwner();
var treeManager = new BehaviorTreeManager(treeManagerOwner);
var treeOwner = new BehaviorTreeOwner();
var tree = treeManager.CreateTree(treeOwner, path, null);
while (tree.RootTask.LastResult == TaskResult.Running)
{
tree.Update();
treeOwner.Tick(100);
}
}
private void Awake()
{
BehaviorTreeSerializer.Initialize(new FlatBuffersSerializer());
treeManager = new BehaviorTreeManager(this);
if (asset == null)
{
return;
}
var treeDesc = BehaviorTreeSerializer.DeserializeDesc(asset.bytes);
tree = treeManager.CreateTree(this, treeDesc);
}
public void TestRestore()
{
BehaviorTreeSerializer.Initialize(new FlatBuffersSerializer());
var treeManagerOwner = new BehaviorTreeManagerOwner();
var treeManager = new BehaviorTreeManager(treeManagerOwner);
var treeOwner = new BehaviorTreeOwner();
var tree1 = treeManager.CreateTree(treeOwner, "WaitTimer", null);
Console.WriteLine("============ Tree1 ============");
for (int i = 0; i < 20; i++)
{
tree1.Update();
treeOwner.Tick(100);
}
var snapshot1 = tree1.CreateSnapshot();
var data1 = BehaviorTreeSerializer.SerializeProps(snapshot1);
var snapshot2 = BehaviorTreeSerializer.DeserializeProps(data1);
Console.WriteLine("============ Tree2 ============");
var tree2 = treeManager.CreateTree(treeOwner, "WaitTimer", null);
for (int i = 0; i < 30; i++)
{
tree2.Update();
treeOwner.Tick(100);
}
Console.WriteLine("============ Tree2 Restore ============");
tree2.RestoreSnapshot(snapshot2);
for (int i = 0; i < 1000 && tree2.RootTask.LastResult == TaskResult.Running; i++)
{
tree2.Update();
treeOwner.Tick(100);
}
}
public override IEnumerator Tick(WaitForSeconds delayStart = null)
{
base.Tick();
++numTicks;
if (UpdatePlayersTickInterval % numTicks == 0 || numTicks == 0)
{
players = GameObject.FindGameObjectsWithTag("Player");
}
if (UpdateSelfPositionTickInterval % numTicks == 0 || numTicks == 0)
{
myPos = BehaviorTreeManager.GetComponentInParent <Transform>();
}
if (players != null && players.Length > 0)
{
var closestPlayer = GetClosestEnemy(players);
yield return(MoveTowardsPosition(closestPlayer.position));
}
CurrentState = BehaviorState.Fail;
yield return(null);
}
void GenerateBehaviors()
{
Animator a = GetAnimator();
////////////////////////////////// Movement //////////////////////////////////
EvadeNode evade = new EvadeNode(this.rB, speed, 0.4f, 25);
IsBlockedNode isBlocked = new IsBlockedNode(transform, evade, 1, 1);
MoveNode move = new MoveNode(rB, target, speed, atkRange);
SequenceNode evading = new SequenceNode(new List <Node>()
{
isBlocked, evade
});
SelectorNode movement = new SelectorNode(new List <Node>()
{
evading, move
});
////////////////////////////////// Death //////////////////////////////////
HealthCheckNode isDead = new HealthCheckNode(this, 0, true);
ClampSuccessNode isDeadClamped = new ClampSuccessNode(isDead);
AnimationNode deathAnim = new AnimationNode(a, "Die");
OnAnimationCompleteNode onDeathAnimComplete = new OnAnimationCompleteNode(a, "Die");
DestroyNode destroy = new DestroyNode(this.gameObject);
SequenceNode death = new SequenceNode(new List <Node> {
isDeadClamped, deathAnim, onDeathAnimComplete, destroy
});
////////////////////////////////// Cover //////////////////////////////////
HealthCheckNode isLow = new HealthCheckNode(this, consideredLowHP, true);
SoundNode hurtSFX = new SoundNode(Sound.SeaMonsterHurt);
RandomNode chanceHurtSFX = new RandomNode(hurtSFX, 0.4f);
ColorFlashNode hurtFlash = new ColorFlashNode(GetMaterial(), Color.red, 3, 1);
RecoverHealthNode hpRecover = new RecoverHealthNode(this, hpRecoveryMultiplier);
FindCover findCover = new FindCover(this, target, 10);
SequenceNode hurting = new SequenceNode(new List <Node>()
{
chanceHurtSFX, hurtFlash
});
SequenceNode recovering = new SequenceNode(new List <Node>()
{
hpRecover, hurting
});
SequenceNode covering = new SequenceNode(new List <Node>()
{
findCover, movement
});
ParallelNode recoveringAndCovering = new ParallelNode(new List <Node>()
{
recovering, covering
}, 2);
SequenceNode cover = new SequenceNode(new List <Node>()
{
isLow, recoveringAndCovering
});
////////////////////////////////// Attack //////////////////////////////////
// Condition To Start Attack Sequence
IsInRangeNode isInATKRange = new IsInRangeNode(atkRange, transform, target);
// Attack Sequence
AnimationNode readyUpAnim = new AnimationNode(a, "Aim");
LookNode aim = new LookNode(rB, target, 1, 12, 7);
AnimationNode strikeAnim = new AnimationNode(a, "Fire");
TimerNode atkTimer = new TimerNode(1);
// Wrapping Nodes
SequenceNode attackPattern = new SequenceNode(new List <Node>()
{
readyUpAnim, aim, strikeAnim, atkTimer
});
ResetOnStateNode resetATK = new ResetOnStateNode(attackPattern, NodeState.SUCCESS);
SequenceNode attacking = new SequenceNode(new List <Node>()
{
isInATKRange, resetATK
});
SelectorNode attack = new SelectorNode(new List <Node>()
{
attacking, movement
});
////////////////////////////////// Patrol //////////////////////////////////
PatrolNode patrolMove = new PatrolNode(rB, Mathf.RoundToInt(speed * 0.7f), 0.5f, 6, 20, 1.5f, 4);
SelectorNode evadeAndPatrol = new SelectorNode(new List <Node>()
{
evading, patrolMove
});
SpotTargetNode spotTarget = new SpotTargetNode(transform, 40, 80, LayerMask.NameToLayer("Target"), LayerMask.NameToLayer("Enemy"));
FlagNode flag = new FlagNode(NodeState.SUCCESS, NodeState.FAILURE);
FlagActivator flagActivator = new FlagActivator(flag);
SequenceNode spotAndStop = new SequenceNode(new List <Node>()
{
spotTarget, flagActivator
});
SelectorNode patroling = new SelectorNode(new List <Node>()
{
spotAndStop, evadeAndPatrol
});
SequenceNode patrol = new SequenceNode(new List <Node>()
{
flag, patroling
});
////////////////////////////////// Top Node //////////////////////////////////
topNode = new Tree(new SelectorNode(new List <Node>()
{
death, cover, patrol, attack
}));
BehaviorTreeManager.AddTree(topNode);
}
