public void Sequence_Red()
{
var sequence = new SequenceNode();
sequence.Append(new TaskFailureNode());
sequence.Append(new TaskSuccessNode());
sequence.Append(new TaskSuccessNode());
Assert.That(sequence.Run(null), Is.Not.EqualTo(NodeState.Success));
}
public void ConditionFailSingle()
{
var root = new SequenceNode();
var succ = new TaskSuccessNode();
succ.AppendDecorator(new ConditionFail());
root.Append(succ);
root.Append(new TaskFailureNode());
Assert.That(root.Run(null), Is.EqualTo(NodeState.Failure)); //should skip the success condition
Assert.That(succ.executed, Is.EqualTo(false));
}
public void SequenceFailCalled()
{
var sequence = new SequenceNode();
var fail = new TaskFailureNode();
var success = new TaskSuccessNode();
sequence.Append(new TaskSuccessNode());
sequence.Append(fail);
sequence.Append(success);
Assert.That(sequence.Run(null), Is.EqualTo(NodeState.Failure));
Assert.That(fail.executed, Is.EqualTo(true));
Assert.That(success.executed, Is.EqualTo(false));
}
public void ConditionMultiple()
{
var root = new SequenceNode();
var succ = new TaskSuccessNode();
succ.AppendDecorator(new ConditionSuccess());
succ.AppendDecorator(new ConditionFail());
root.Append(succ);
root.Append(new TaskFailureNode());
//expected condition false
Assert.That(root.Run(null), Is.EqualTo(NodeState.Failure));
Assert.That(succ.executed, Is.EqualTo(false));
}
/// <summary>
/// Build the tree as a sequential series of 'if' nodes. Provided that the code generated
/// for each Rule is guaranteed to return, this is functionally equivalent to an if-else chain.
/// </summary>
private Node?BuildSequence()
{
// check that sequence nodes are permitted
if (!spec.Config.AllowSequence)
{
return(null);
}
if (ruleSet.NumRules < 2)
{
return(null);
}
if (spec.Config.Verbose)
{
Console.WriteLine("Building sequence for {0} rules.", ruleSet.NumRules);
}
var node = new SequenceNode(spec);
// iterate through Rules
foreach (RuleSetEntry entry in ruleSet)
{
// append an if-else node to the sequence
node.Append(CreateIfElseNode(entry, new EmptyNode(spec)));
}
return(node);
}
public void ConditionSuccessSingle()
{
var root = new SequenceNode();
var succ = new TaskSuccessNode();
succ.AppendDecorator(new ConditionSuccess());
root.Append(succ);
var fail = new TaskFailureNode();
fail.AppendDecorator(new ConditionFail());
root.Append(fail);
Assert.That(root.Run(null), Is.EqualTo(NodeState.Success)); //should skip the fail node
Assert.That(succ.executed, Is.EqualTo(true));
Assert.That(fail.executed, Is.EqualTo(false));
}
//[UnityTest]
public IEnumerator SequenceNodeTest()
{
var stopwatch = new Stopwatch();
stopwatch.Start();
var sequenceNode = new SequenceNode();
sequenceNode.Append(DelayAction.Allocate(1, () => { }));
sequenceNode.Append(DelayAction.Allocate(1, () => { }));
sequenceNode.Append(DelayAction.Allocate(1, () => { stopwatch.Stop(); }));
while (!sequenceNode.Execute(Time.deltaTime))
{
yield return(null);
}
Debug.Log(stopwatch.ElapsedMilliseconds);
}
public void Append(ProcessNode node)
{
if (null == mSequenceNode)
{
mSequenceNode = new SequenceNode();
}
mSequenceNode.Append(node);
}
public void SequenceRunning_Green()
{
var sequence = new SequenceNode();
var run = new TaskRunningNode();
var succ = new TaskSuccessNode();
sequence.Append(run);
sequence.Append(succ);
Assert.That(sequence.Run(null), Is.EqualTo(NodeState.Running));
Assert.That(sequence.Run(null), Is.EqualTo(NodeState.Running));
Assert.That(sequence.Run(null), Is.EqualTo(NodeState.Running));
Assert.That(sequence.Run(null), Is.EqualTo(NodeState.Running));
Assert.That(succ.executed, Is.EqualTo(false)); //node not called
Assert.That(sequence.Run(null), Is.EqualTo(NodeState.Success)); //step forward, tree unlocked, next node called
Assert.That(succ.executed, Is.EqualTo(true)); //condition satisfied
}
public void SequenceRunning_Red()
{
var sequence = new SequenceNode();
var run = new TaskRunningNode();
var fail = new TaskFailureNode();
var succ = new TaskSuccessNode();
sequence.Append(run);
sequence.Append(fail);
sequence.Append(succ);
Assert.That(sequence.Run(null), Is.EqualTo(NodeState.Running));
Assert.That(sequence.Run(null), Is.EqualTo(NodeState.Running));
Assert.That(sequence.Run(null), Is.EqualTo(NodeState.Running));
Assert.That(sequence.Run(null), Is.EqualTo(NodeState.Running));
Assert.That(sequence.Run(null), Is.EqualTo(NodeState.Failure));
Assert.That(fail.executed, Is.EqualTo(true)); //condition satisfied
Assert.That(succ.executed, Is.EqualTo(false)); //condition satisfied
}
public void Tag_Green()
{
var root = new SequenceNode();
var suc = new TaskSuccessNode();
suc.AppendDecorator(new Tag("foo"));
root.Append(suc);
var bt = new BT.BT(root);
bt.Run();
Assert.That(bt.GetActiveTag(), Is.EqualTo("foo"));
}
/// <summary>
/// The last Rule is often a 'fallback' rule with an empty condition. If this is the case,
/// we can sometimes perform an optimisation that reduces the overall code size.
/// </summary>
/// <returns>Root of the generated tree.</returns>
private Node?BuildFallbackSequence()
{
// sanity check
if (ruleSet.NumRules <= 1)
{
return(null);
}
// check that there is a fallback rule
RuleSetEntry lastRule = ruleSet[ruleSet.NumRules - 1];
if (!lastRule.EffectiveCondition.IsEmpty)
{
return(null);
}
// check that sequence nodes are permitted
if (!spec.Config.AllowSequence)
{
return(null);
}
if (spec.Config.Verbose)
{
Console.WriteLine("Performing fallback sequence optimisation.");
}
// remove the fallback rule and build the tree
RuleSet rSet = ruleSet.DeriveExcludingLast();
var builder = new TreeBuilder(spec, rSet, this);
Node node = builder.Build();
// ensure that there is a sequence node including the root
// of the tree
SequenceNode seq;
if (node is SequenceNode)
{
seq = (SequenceNode)node;
}
else
{
seq = new SequenceNode(spec);
seq.Append(node);
}
// now paste the fallback rule onto the end of the sequence
seq.Append(lastRule.Rule);
return(seq);
}
public void SetValueAfterExecution_Green()
{
var root = new SequenceNode();
var bt = new BT.BT(root);
var suc = new TaskSuccessNode();
suc.AppendDecorator(new SetValueAfterExecution("foo", () => 10)); //for example set target position
root.Append(suc);
bt.Run();
Assert.That(bt.BlackBoard.ReadValue <int>("foo"), Is.EqualTo(10));
}
private void Start()
{
this.Sequence()
.Delay(1.0f)
.Event(() => Log.I("Sequence1 延时了 1s"))
.Begin()
.OnDisposed(() => { Log.I("Sequence1 destroyed"); });
var sequenceNode2 = new SequenceNode(DelayAction.Allocate(1.5f));
sequenceNode2.Append(EventAction.Allocate(() => Log.I("Sequence2 延时 1.5s")));
sequenceNode2.Append(DelayAction.Allocate(0.5f));
sequenceNode2.Append(EventAction.Allocate(() => Log.I("Sequence2 延时 2.0s")));
this.ExecuteNode(sequenceNode2);
/* 这种方式需要自己手动进行销毁
* sequenceNode2.Dispose();
* sequenceNode2 = null;
*/
// 或者 OnDestroy 触发时进行销毁
sequenceNode2.DisposeWhenGameObjectDestroyed(this);
}
public void WriteOnFailure_Green()
{
var root = new SequenceNode();
var fail = new TaskFailureNode();
fail.AppendDecorator(new SetValueOnFail("foo", () => 1));
root.Append(fail);
BT.BT bt = new BT.BT(root);
bt.BlackBoard.SetValue("foo", 0);
Assert.That(bt.BlackBoard.ReadValue <int>("foo"), Is.EqualTo(0));
bt.Run();
Assert.That(bt.BlackBoard.ReadValue <int>("foo"), Is.EqualTo(1));
}
public void WriteOnFailure_Red()
{
var root = new SequenceNode();
var suc = new TaskSuccessNode();
suc.AppendDecorator(new SetValueOnFail("foo", () => 1));
root.Append(suc);
BT.BT bt = new BT.BT(root);
bt.BlackBoard.SetValue("foo", 0);
Assert.That(bt.BlackBoard.ReadValue <int>("foo"), Is.EqualTo(0));
bt.Run();
Assert.That(bt.BlackBoard.ReadValue <int>("foo"), Is.EqualTo(0));
}
public void ConditionConstant_Red()
{
var root = new SequenceNode();
var bt = new BT.BT(root);
bt.BlackBoard.SetValue("foo", 10);
var suc = new TaskSuccessNode();
suc.AppendDecorator(new BlackBoardConstantCondition <IntCondition, int>("foo", 10, ConditionType.Equal)); //for example set target position
root.Append(suc);
bt.Run();
Assert.That(suc.executed, Is.Not.EqualTo(false));
}
void Start()
{
// 创建一个序列容器
var sequenecNode = new SequenceNode();
// 添加子节点
sequenecNode.Append(DelayAction.Allocate(1.0f, () => Debug.Log("延时 1 秒" + DateTime.Now)));
sequenecNode.Append(DelayAction.Allocate(1.0f, () => Debug.Log("延时 1 秒" + DateTime.Now)));
sequenecNode.Append(DelayAction.Allocate(1.0f, () => Debug.Log("延时 1 秒" + DateTime.Now)));
sequenecNode.Append(DelayAction.Allocate(1.0f, () => Debug.Log("延时 1 秒" + DateTime.Now)));
sequenecNode.Append(DelayAction.Allocate(1.0f, () => Debug.Log("延时 1 秒" + DateTime.Now)));
sequenecNode.Append(DelayAction.Allocate(1.0f, () => Debug.Log("延时 1 秒" + DateTime.Now)));
// 执行节点
this.ExecuteNode(sequenecNode);
}
public override IExecuteNodeChain Append(IExecuteNode node)
{
mSequenceNode.Append(node);
return(this);
}
public override IActionChain Append(IAction node)
{
mSequenceNode.Append(node);
return(this);
}
