protected IEnumerator Sequence (params IEnumerator[] children)
{
SequenceData sequence = new SequenceData ();
return Control (
sequence,
() => {
if (sequence.Index >= children.Length)
{
return Success;
}
IEnumerator child = children[sequence.Index];
// Fail on break or explicit failure
if (!child.MoveNext () || Failure.Equals (child.Current))
{
return Failure;
}
// Move to next on success
if (Success.Equals (child.Current))
{
sequence.Index = sequence.Index + 1;
}
return Running;
},
children
);
}
public void EqualsOther_SourceIsDefaultAndOtherIsDefault_ExpectTrue()
{
var source = new Failure <decimal>();
var other = default(Failure <decimal>);
var actual = source.Equals(other);
Assert.True(actual);
}
public void Equals_FailureAIsDefaultAndFailureBIsDefault_ExpectTrue()
{
var failureA = default(Failure <int>);
var failureB = new Failure <int>();
var actual = Failure.Equals(failureA, failureB);
Assert.True(actual);
}
public void EqualsStatic_FailureAIsDefaultAndFailureBIsDefault_ExpectTrue()
{
var failureA = default(Failure <SomeFailureCode>);
var failureB = new Failure <SomeFailureCode>();
var actual = Failure <SomeFailureCode> .Equals(failureA, failureB);
Assert.True(actual);
}
IEnumerator Control (NodeData data, System.Func<ResultType> logic, IEnumerator[] children)
{
// Collect node data from children (for use in reset)
Dictionary<IEnumerator, NodeData> childData = new Dictionary<IEnumerator, NodeData> ();
foreach (IEnumerator child in children)
{
child.MoveNext ();
childData[child] = child.Current as NodeData;
}
// Yield own node data
yield return data;
// Fail on no children
if (children.Length < 1)
{
yield return Failure;
}
ResultType result = Success;
// Main flow
while (!data.ShouldReset)
{
result = logic ();
if (Success.Equals (result) || Failure.Equals (result))
{
break;
}
yield return Running;
}
// Reset children
foreach (KeyValuePair<IEnumerator, NodeData> pair in childData)
{
if (pair.Value == null)
{
continue;
}
pair.Value.Reset ();
pair.Key.MoveNext ();
}
yield return result;
}
protected IEnumerator Run (ExecutionMode mode)
{
WaitForSeconds frameDelay = new WaitForSeconds (1.0f / Frequency);
do
{
// Start running the tree root - grabbing its node data yielded on the init frame
IEnumerator rootRoutine = Root ();
rootRoutine.MoveNext ();
m_RootData = rootRoutine.Current as NodeData;
// Keep running until we're disabled
while (Application.isPlaying && enabled)
{
// Break out if the root was reset
if (m_RootData != null && m_RootData.ShouldReset)
{
break;
}
// Break out if the tree breaks or completes with success or failure
if (!rootRoutine.MoveNext () || Success.Equals (rootRoutine.Current) || Failure.Equals (rootRoutine.Current))
{
break;
}
yield return frameDelay;
}
// Reset the root
if (m_RootData != null)
{
m_RootData.Reset ();
rootRoutine.MoveNext ();
}
}
while (mode == ExecutionMode.Continuous && Application.isPlaying && enabled);
}
public static bool Equals <TFailureCode>(Failure <TFailureCode> left, Failure <TFailureCode> right)
where TFailureCode : struct
=>
left.Equals(right);
public static bool Equals(Failure <TFailureCode> left, Failure <TFailureCode> right) => left.Equals(right);