public IEnumerator ActivateOnlyAfterOnePass()
{
// Given a behaviors sequence,
EndlessBehavior endlessBehavior = new EndlessBehavior();
BehaviorSequence sequence = new BehaviorSequence(true, new List <IBehavior> {
endlessBehavior
});
// When we activate it,
sequence.LifeCycle.Activate();
yield return(null);
sequence.Update();
// Then it is activated only after one pass.
endlessBehavior.LifeCycle.MarkToFastForward();
yield return(null);
sequence.Update();
yield return(null);
sequence.Update();
Assert.AreEqual(Stage.Active, sequence.LifeCycle.Stage);
// Cleanup.
sequence.LifeCycle.Deactivate();
}
public IEnumerator SkipChildNotWhenItIsExecuted()
{
// Given an activating behavior sequence of one not optional and one optional behavior,
OptionalEndlessBehavior optional = new OptionalEndlessBehavior();
EndlessBehavior notOptional = new EndlessBehavior();
BehaviorSequence sequence = new BehaviorSequence(false, new List <IBehavior>
{
notOptional,
optional,
});
sequence.Configure(RuntimeConfigurator.Configuration.GetCurrentMode());
sequence.LifeCycle.Activate();
yield return(null);
sequence.Update();
// When the optional behavior is marked to be skipped before it was its turn,
sequence.Configure(new Mode("Test", new WhitelistTypeRule <IOptional>().Add <OptionalEndlessBehavior>()));
notOptional.LifeCycle.MarkToFastForwardStage(Stage.Activating);
notOptional.LifeCycle.MarkToFastForwardStage(Stage.Deactivating);
while (notOptional.LifeCycle.Stage != Stage.Inactive)
{
yield return(null);
sequence.Update();
}
while (sequence.LifeCycle.Stage != Stage.Active)
{
Assert.AreEqual(Stage.Inactive, optional.LifeCycle.Stage);
yield return(null);
sequence.Update();
}
// Then it is skipped.
Assert.AreEqual(Stage.Active, sequence.LifeCycle.Stage);
yield break;
}
public IEnumerator UnskipChild()
{
// Given an activating repeating behavior sequence of one not optional and one skipped optional behavior,
OptionalEndlessBehavior optional = new OptionalEndlessBehavior();
EndlessBehavior notOptional = new EndlessBehavior();
BehaviorSequence sequence = new BehaviorSequence(true, new List <IBehavior>
{
notOptional,
optional,
});
sequence.Configure(RuntimeConfigurator.Configuration.GetCurrentMode());
sequence.LifeCycle.Activate();
yield return(null);
sequence.Update();
notOptional.LifeCycle.MarkToFastForwardStage(Stage.Activating);
notOptional.LifeCycle.MarkToFastForwardStage(Stage.Deactivating);
sequence.Configure(new Mode("Test", new WhitelistTypeRule <IOptional>().Add <OptionalEndlessBehavior>()));
yield return(null);
sequence.Update();
//When you re-enable it,
sequence.Configure(RuntimeConfigurator.Configuration.GetCurrentMode());
notOptional.LifeCycle.MarkToFastForwardStage(Stage.Activating);
notOptional.LifeCycle.MarkToFastForwardStage(Stage.Deactivating);
while (optional.LifeCycle.Stage != Stage.Activating)
{
yield return(null);
sequence.Update();
}
// Then it is not skipped when it's its turn.
Assert.AreEqual(Stage.Activating, optional.LifeCycle.Stage);
}
public IEnumerator DoNotRepeat()
{
// Given a behaviors sequence with RepeatsMode = Once,
DelayBehavior childBehavior = new DelayBehavior(shortDelay);
BehaviorSequence sequence = new BehaviorSequence(false, new List <IBehavior> {
childBehavior
});
// When we activate it,
sequence.LifeCycle.Activate();
yield return(null);
sequence.Update();
// Then it completes its activation only after every child behavior was activated once.
Assert.AreEqual(Stage.Activating, sequence.LifeCycle.Stage);
Assert.AreEqual(Stage.Activating, childBehavior.LifeCycle.Stage);
while (childBehavior.LifeCycle.Stage != Stage.Active)
{
yield return(null);
sequence.Update();
}
while (sequence.LifeCycle.Stage != Stage.Active)
{
yield return(null);
sequence.Update();
Assert.AreNotEqual(Stage.Activating, childBehavior.LifeCycle.Stage);
}
Assert.AreEqual(Stage.Active, sequence.LifeCycle.Stage);
// Cleanup.
sequence.LifeCycle.Deactivate();
}
public IEnumerator BehaviorsActivatedInSuccession()
{
// Given a sequence with two behaviors,
BehaviorSequence sequence = new BehaviorSequence(true, new List <IBehavior>
{
new DelayBehavior(shortDelay),
new DelayBehavior(shortDelay)
});
// When we activate it,
sequence.LifeCycle.Activate();
// One is activated only after the previous one is deactivated.
yield return(null);
sequence.Update();
List <IBehavior> behaviors = sequence.Data.Behaviors;
Assert.AreEqual(Stage.Activating, behaviors[0].LifeCycle.Stage);
while (behaviors[0].LifeCycle.Stage != Stage.Inactive)
{
Assert.AreEqual(Stage.Inactive, behaviors[1].LifeCycle.Stage);
yield return(null);
sequence.Update();
}
yield return(null);
sequence.Update();
Assert.AreEqual(Stage.Activating, behaviors[1].LifeCycle.Stage);
// Cleanup.
sequence.LifeCycle.Deactivate();
}
