public void ContinuesAfterSuccess()
{
// three children: success, failure, other
// index should continue after success and tick failure
// index should restart after failure and success should be ticked again
// halt should be called on all children after each failure
var alwaysSuccessChild = new ReturnXNode(NodeStatus.SUCCESS);
var alwaysFailureChild = new ReturnXNode(NodeStatus.FAILURE);
var otherChild = new ReturnXNode(NodeStatus.SUCCESS);
var node = new SequenceNode(new List <INode>
{
alwaysSuccessChild,
alwaysFailureChild,
otherChild,
});
var status = node.Tick();
Assert.That(status, Is.EqualTo(NodeStatus.FAILURE));
Assert.That(alwaysSuccessChild.Ticks, Is.EqualTo(1));
Assert.That(alwaysFailureChild.Ticks, Is.EqualTo(1));
Assert.That(otherChild.Ticks, Is.EqualTo(0));
Assert.That(alwaysSuccessChild.Halts, Is.EqualTo(1));
Assert.That(alwaysFailureChild.Halts, Is.EqualTo(1));
Assert.That(otherChild.Halts, Is.EqualTo(1));
status = node.Tick();
Assert.That(status, Is.EqualTo(NodeStatus.FAILURE));
Assert.That(alwaysSuccessChild.Ticks, Is.EqualTo(2));
Assert.That(alwaysFailureChild.Ticks, Is.EqualTo(2));
Assert.That(otherChild.Ticks, Is.EqualTo(0));
Assert.That(alwaysSuccessChild.Halts, Is.EqualTo(2));
Assert.That(alwaysFailureChild.Halts, Is.EqualTo(2));
Assert.That(otherChild.Halts, Is.EqualTo(2));
}
public void NoChildrenReturnsSuccess()
{
var node = new SequenceNode(Array.Empty <INode>());
var status = node.Tick();
Assert.That(status, Is.EqualTo(NodeStatus.SUCCESS));
}
public static void LoadChildren(SequenceNode root, YamlSequenceNode sequence)
{
foreach (var child in sequence.Children)
{
if (child is YamlSequenceNode)
{
var node = root.AddChild(new SequenceNode(root.Value, child, ImageLoad.GetImageIndex(child), id, root));
id++;
LoadChildren(node as SequenceNode, child as YamlSequenceNode);
}
else if (child is YamlMappingNode)
{
var teste = child as YamlMappingNode;
var node = root.AddChild(new MappingNode(root.Value, child, ImageLoad.GetImageIndex(child), id, root));
id++;
LoadChildren(node as MappingNode, child as YamlMappingNode);
}
else if (child is YamlScalarNode)
{
var scalar = child as YamlScalarNode;
var node = root.AddChild(new ScalarNode(scalar.Value, child, scalar.Tag, ImageLoad.GetImageIndex(child), id, root));
id++;
}
}
}
public void Run()
{
_node = this.Sequence(this.env)
.While(() => {
return(percent < 1);
},
() => {
if (recyled)
{
return;
}
_curdur += Time.deltaTime;
MoveNext();
})
.OnCompelete(() =>
{
_curdur = 0;
OnComplete();
if (onCompelete != null)
{
onCompelete();
}
compeleted = true;
})
.Run();
}
protected internal virtual void VisitSequence(SequenceNode node)
{
foreach (var child in node.Nodes)
{
Visit(child);
}
}
public static void LoadTreeNode(TreeNode treeNode, SequenceNode rootNode)
{
foreach (var child in rootNode.Children)
{
if (child is ScalarNode)
{
ScalarNode scalarChild = (ScalarNode)child;
var node = treeNode.Nodes.Add(scalarChild.Value);
node.ImageIndex = scalarChild.ImageIndex;
node.Tag = child.Tag;
}
else if (child is SequenceNode)
{
var node = treeNode.Nodes.Add(child.Value);
node.Tag = child.Tag;
node.ImageIndex = child.ImageIndex;
LoadTreeNode(node, child as SequenceNode);
}
else if (child is MappingNode)
{
var node = treeNode.Nodes.Add(child.Value);
node.Tag = child.Tag;
node.ImageIndex = child.ImageIndex;
LoadTreeNode(node, child as MappingNode);
}
}
}
private void RemoveTween(object node)
{
SequenceNode mNode = node as SequenceNode;
sequence.nodes.Remove(mNode);
EditorUtility.SetDirty(tweener);
}
/// <summary>
///
/// </summary>
/// <param name="node_"></param>
public virtual void Load(XmlNode node_)
{
Id = int.Parse(node_.Attributes["id"].Value);
if (_newId <= Id)
{
_newId = Id + 1;
}
Name = node_.Attributes["name"].Value;
Description = node_.Attributes["description"].Value;
foreach (XmlNode nodeNode in node_.SelectNodes("NodeList/Node"))
{
int versionNode = int.Parse(nodeNode.Attributes["version"].Value);
SequenceNode seqNode = SequenceNode.CreateNodeFromXml(nodeNode);
if (seqNode != null)
{
AddNode(seqNode);
}
else
{
throw new InvalidOperationException("Can't create SequenceNode from xml " + string.Format("id={0}", nodeNode.Attributes["id"].Value));
}
}
}
protected override void OnDispose()
{
base.OnDispose();
_repeatNode?.Dispose();
_repeatNode = null;
_sequenceNode = null;
}
private IEnumerator JumpSequence(MovementSequence _sequence, SequenceNode _node, SequenceCallback _completionCallback)
{
float _jumpSpeed = jumpStartSpeed;
Vector2 _peak;
if (zoneNumber == 0)
{
_peak = new Vector2(
(character.transform.position.x + _node.transform.position.x) / 2,
Mathf.Max(character.transform.position.y, _node.transform.position.y) + 1f
);
}
else if (zoneNumber == 1)
{
_peak = new Vector2(
Mathf.Min(character.transform.position.x, _node.transform.position.x) - 1f,
(character.transform.position.y + _node.transform.position.y) / 2f
);
}
else if (zoneNumber == 2)
{
_peak = new Vector2(
(character.transform.position.x + _node.transform.position.x) / 2,
Mathf.Min(character.transform.position.y, _node.transform.position.y) - 1f
);
}
else
{
_peak = new Vector2(
Mathf.Max(character.transform.position.x, _node.transform.position.x) + 1f,
(character.transform.position.y + _node.transform.position.y) / 2f
);
}
while (Vector2.Distance(character.transform.position, _peak) > 0.1f)
{
character.transform.position = Vector2.MoveTowards(character.transform.position, _peak, _jumpSpeed * Time.deltaTime);
if (_jumpSpeed < jumpMaxSpeed)
{
_jumpSpeed += jumpSpeedIncrease * Time.deltaTime;
}
yield return(new WaitForEndOfFrame());
}
while (Vector2.Distance(character.transform.position, _node.transform.position) > 0.1f)
{
character.transform.position = Vector2.MoveTowards(character.transform.position, _node.transform.position, _jumpSpeed * Time.deltaTime);
if (_jumpSpeed < jumpMaxSpeed)
{
_jumpSpeed += jumpSpeedIncrease * Time.deltaTime;
}
yield return(new WaitForEndOfFrame());
}
moveNextNode(_sequence, _completionCallback);
yield return(new WaitForEndOfFrame());
}
void BuildTree()
{
var rootRepeat = new NaiveRepeater("rootRepeat", bt);
var rootSel = new SelectorNode("rootSel", bt);
var parry = new ActionNode("parry", Parry, bt);
var counter = new ActionNode("counter", Counter, bt);
var defendSeq = new SequenceNode("defendSeq", bt);
var attackAndRecover = new ActionNode("attackAndRecover", AttackAndRecover, bt);
var attacked = new ActionNode("attacked", Attacked, bt);
var dashSel = new SelectorNode("dashSel", bt);
var back = new ActionNode("back", Back, bt);
var attackSeq = new SequenceNode("attackSeq", bt);
rootRepeat.Build(
rootSel.Build(
defendSeq.Build(
parry,
counter
),
attackSeq.Build(
dashSel.Build(
attackAndRecover,
attacked
),
back
)
)
);
bt.Build(rootRepeat);
}
public void Sequence_Node_Succeds_When_All_Childs_Succeeds(int childsCount)
{
SequenceNode seq = new SequenceNode();
for (int i = 0; i < childsCount; i++)
{
var mock = Substitute.For <BTNode>();
mock.Update().Returns(NodeState.Success);
seq.AddChild(mock);
}
if (childsCount == 0)
{
Assert.IsTrue(seq.Update() == NodeState.Success);
}
else
{
for (int i = 0; i < childsCount; i++)
{
if (i == childsCount - 1)
{
Assert.IsTrue(seq.Update() == NodeState.Success);
}
else
{
Assert.IsTrue(seq.Update() == NodeState.Running);
}
}
}
}
private void SequenceAddedInvoker(SequenceNode sequence)
{
if (SequenceAdded != null)
{
SequenceAdded(this, new SequenceAddedArgs(sequence));
}
}
public void RestartsAfterRunning()
{
// three children: success, running, other
// index should continue after success and tick running
// index should restart after running, and success should be ticked again
// halts should not be called on incomplete sequences
var success = new ReturnXNode(NodeStatus.SUCCESS);
var running = new ReturnXNode(NodeStatus.RUNNING);
var other = new ReturnXNode(NodeStatus.SUCCESS);
var node = new SequenceNode(new List <INode>
{
success,
running,
other,
});
var status = node.Tick();
Assert.That(status, Is.EqualTo(NodeStatus.RUNNING));
Assert.That(success.Ticks, Is.EqualTo(1));
Assert.That(running.Ticks, Is.EqualTo(1));
Assert.That(other.Ticks, Is.EqualTo(0));
Assert.That(success.Halts, Is.EqualTo(0));
Assert.That(running.Halts, Is.EqualTo(0));
Assert.That(other.Halts, Is.EqualTo(0));
status = node.Tick();
Assert.That(status, Is.EqualTo(NodeStatus.RUNNING));
Assert.That(success.Ticks, Is.EqualTo(2));
Assert.That(running.Ticks, Is.EqualTo(2));
Assert.That(other.Ticks, Is.EqualTo(0));
Assert.That(success.Halts, Is.EqualTo(0));
Assert.That(running.Halts, Is.EqualTo(0));
Assert.That(other.Halts, Is.EqualTo(0));
}
internal override GlobNode StartLevel()
{
var node = new SequenceNode(this);
nodes.Add(node);
return(node.StartLevel());
}
public void Start()
{
sendheartPackTime = 0f;
recvHearPackTime = 0f;
sequenceNodeHeartPack = monoBehaviour.Sequence().Repeat(-1, hearPackInterval, Send).Begin();
MsgManager.Instance.Regist(MsgID.HearBeat, RecvHeartPack);
}
private void CreateBehaviourTree()
{
behaviourTree = new BehaviourTreeEngine(false);
rootSequence = behaviourTree.CreateSequenceNode("Root", false);
selectorDoor = behaviourTree.CreateSelectorNode("Selector door");
sequenceDoor = behaviourTree.CreateSequenceNode("Sequence door", false);
walkToDoor1 = behaviourTree.CreateLeafNode("Walk to door 1", WalkToDoor, ArriveToDoor);
walkToDoor2 = behaviourTree.CreateLeafNode("Walk to door 2", WalkToDoor, ArriveToDoor);
enterTheHouse = behaviourTree.CreateLeafNode("Enter the house", EnterTheHouse, HasEnteredTheHouse);
openDoor1 = behaviourTree.CreateLeafNode("Open the door 1", OpenDoor, DoorOpened);
openDoor2 = behaviourTree.CreateLeafNode("Open the door 2", OpenDoor, DoorOpened);
unlockDoor = behaviourTree.CreateLeafNode("Find key", UnlockDoor, IsTheDoorUnlocked);
smashDoor = behaviourTree.CreateLeafNode("Explode door", SmashDoor, DoorSmashed);
rootSequence.AddChild(walkToDoor1);
rootSequence.AddChild(selectorDoor);
rootSequence.AddChild(enterTheHouse);
selectorDoor.AddChild(openDoor1);
selectorDoor.AddChild(sequenceDoor);
selectorDoor.AddChild(smashDoor);
sequenceDoor.AddChild(unlockDoor);
sequenceDoor.AddChild(walkToDoor2);
sequenceDoor.AddChild(openDoor2);
behaviourTree.SetRootNode(rootSequence);
}
public MockBehaviourTreeDFS() : base()
{
SequenceNode seq1 = new SequenceNode();
SequenceNode seq2 = new SequenceNode();
for (int i = 0; i < 4; i++)
{
seq1.AddChild(Substitute.For <BTNode>());
}
for (int i = 0; i < 4; i++)
{
seq2.AddChild(Substitute.For <BTNode>());
}
SequenceNode root = new SequenceNode(new List <BTNode> {
seq1, seq2
});
SetRoot(root);
PerformDFS(x => {
if (x == seq1)
{
result = 1;
}
if (x == seq2)
{
result = 2;
}
});
}
private void ChangeFieldType(BaseNode node, BaseNode parent, int typeInd)
{
BaseNode newNode;
switch (typeInd)
{
case 1:
newNode = new SequenceNode(node.GetChildren(), node.GetId());
break;
case 2:
newNode = new SelectorNode(node.GetChildren(), node.GetId());
break;
case 3:
newNode = new TimeMonitorNode(node.GetChildren(), node.GetId());
break;
default:
newNode = new ActionNode();
newNode.SetId(node.GetId());
break;
}
if (parent == null)
{
HintedExecutionBehaviourTree tree = (HintedExecutionBehaviourTree)target;
tree.tree = newNode;
}
else
{
var changeIndex = parent.GetChildren().FindIndex(x => x == node);
parent.GetChildren()[changeIndex] = newNode;
}
}
public void Behaviour_Tree_Visits_All_Childrens_On_Tick()
{
MockBTNode node = new MockBTNode();
SequenceNode seq1 = new SequenceNode(new List <BTNode> {
node, node, node
});
SequenceNode seq2 = new SequenceNode(new List <BTNode> {
node, node, node
});
SequenceNode root = new SequenceNode(new List <BTNode> {
seq1, seq2
});
BehaviourTree tree = new BehaviourTree(root);
tree.Start();
for (int i = 0; i < 6; i++)
{
tree.Update();
if (i < 5)
{
Assert.IsTrue(tree.TreeState == NodeState.Running);
}
}
Assert.IsTrue(node.started == 6);
Assert.IsTrue(tree.TreeState == NodeState.Success);
}
public void Visit(SequenceNode node)
{
foreach (var s in node.Sequence)
{
s.Accept(this);
}
}
private Node GetCommaNode()
{
ResetPosition();
var n = new SequenceNode();
var buffer = new List <Token>();
do
{
if (ThisToken.Content == ",")
{
n.Sequence.Add(GetAst(buffer));
buffer = new List <Token>();
}
else
{
buffer.Add(ThisToken);
}
} while (NextToken());
if (buffer.Count > 0)
{
n.Sequence.Add(GetAst(buffer));
}
return(n);
}
public override GlobNode AddChar(char c)
{
SequenceNode node = new SequenceNode(this);
_nodes.Add(node);
return(node.AddChar(c));
}
public override GlobNode StartLevel()
{
SequenceNode node = new SequenceNode(this);
_nodes.Add(node);
return(node.StartLevel());
}
internal override GlobNode /*!*/ AddChar(char c)
{
SequenceNode node = new SequenceNode(this);
_nodes.Add(node);
return(node.AddChar(c));
}
internal override GlobNode /*!*/ StartLevel()
{
SequenceNode node = new SequenceNode(this);
_nodes.Add(node);
return(node.StartLevel());
}
public BehaviourTree()
{
finished = false;
// Hard coding of the specific behaviour tree for a student
// outlined in more detail in the provide diagram
// intermediate nodes take a parent, action leaf nodes take in the type of action they are
BNode root = new RepeaterNode(null);
BNode getadvising = new SequenceNode(root);
BNode branch = new SelectorNode(getadvising);
BNode checkdata = new ActionNode(branch, Astar.Actiontype.CHECKDATA);
BNode randomplaque = new SequenceNode(branch);
BNode pathplaque = new ActionNode(randomplaque, Astar.Actiontype.PATHPLAQUE);
BNode checkplaque = new ActionNode(randomplaque, Astar.Actiontype.CHECKPLAQUE);
BNode pathprof3 = new ActionNode(getadvising, Astar.Actiontype.PATHPROF);
BNode pickprof3 = new ActionNode(getadvising, Astar.Actiontype.PICKPROF);
BNode randbranch = new RandSelectorNode(getadvising);
BNode finish = new ActionNode(randbranch, Astar.Actiontype.FINISH);
BNode pathrand = new ActionNode(randbranch, Astar.Actiontype.PATHRAND);
// current is the node being looked at in the tree at any time
current = root;
}
internal override GlobNode AddChar(char c)
{
var node = new SequenceNode(this);
nodes.Add(node);
return(node.AddChar(c));
}
public static SequenceNode CreateRootNode(BBTag[] allowedTags)
{
var node = new SequenceNode();
AddSubnodes(allowedTags, node);
return(node);
}
protected override void OnDispose()
{
base.OnDispose();
mSequenceNode.Dispose();
mSequenceNode = null;
}
public void ActivateTrigger(SequenceNode node) {
if (node==sequenceNodes[sequencePosition]) {
sequencePosition++;
if (sequencePosition == sequenceLength) {
isComplete = true;
sequencePosition = 0; // what happens if you walk back?
Debug.Log("Sequence completed!");
}
}
else {
Debug.Log("Wrong sequence trigger!");
// tell playerControls to increase detection / set as unsafe
if (ResetOnFail) {
sequencePosition = 0;
}
}
}
public override GlobNode StartLevel()
{
SequenceNode node = new SequenceNode(this);
_nodes.Add(node);
return node.StartLevel();
}
internal GlobUngrouper(int patternLength) {
_rootNode = new SequenceNode(null);
_currentNode = _rootNode;
_level = 0;
}
internal override GlobNode/*!*/ AddChar(char c) {
SequenceNode node = new SequenceNode(this);
_nodes.Add(node);
return node.AddChar(c);
}
internal override GlobNode/*!*/ StartLevel() {
SequenceNode node = new SequenceNode(this);
_nodes.Add(node);
return node.StartLevel();
}
private Node Parse()
{
Node n = ParseExpression();
Token t = PeekToken();
if (t == Token.Cut)
{
Expect(Token.Cut);
Node n1 = new CutNode(positions.Count);
positions.Add(n1);
n = new SequenceNode(n, n1);
n = new SequenceNode(n, ParseExpression());
}
return n;
}
internal GlobUngrouper()
{
rootNode = new SequenceNode(null);
currentNode = rootNode;
level = 0;
}
internal override GlobNode StartLevel()
{
var node = new SequenceNode(this);
nodes.Add(node);
return node.StartLevel();
}
private Node ParseSequence()
{
Node n1 = ParseTerm();
for (;;)
{
Token t = PeekToken();
switch (t)
{
case Token.End:
case Token.Or:
case Token.RParen:
case Token.Cut:
return n1;
default:
n1 = new SequenceNode(n1, ParseTerm());
break;
}
}
}
public GlobUngrouper()
{
_rootNode = new SequenceNode(null);
_currentNode = _rootNode;
_level = 0;
}
internal override GlobNode AddChar(char c)
{
var node = new SequenceNode(this);
nodes.Add(node);
return node.AddChar(c);
}
public Regexp Build()
{
Node n = Parse();
Node acc = new AcceptNode(positions.Count);
positions.Add(acc);
n = new SequenceNode(n, acc);
n.ComputeNullable();
n.ComputeFirstPos(this);
n.ComputeLastPos(this);
n.ComputeFollowPos(this);
#if DEBUG
StringBuilder sb = new StringBuilder();
n.Dump(sb);
Debug.WriteLine(sb.ToString());
#endif
State [] states = BuildDfaTable(n);
TableCompacter tc = new TableCompacter(states, charClasses);
tc.Compact();
return new Regexp(alphabet, tc.ReStates, tc.Next, tc.Check);
}
/// <summary>
/// clone
/// </summary>
/// <returns></returns>
public IBehaviourNode Clone()
{
var behaviourNode = new SequenceNode();
base.CopyToCompositeNode(behaviourNode);
return behaviourNode;
}
public override GlobNode AddChar(char c)
{
SequenceNode node = new SequenceNode(this);
_nodes.Add(node);
return node.AddChar(c);
}
