public void testStatefulSel()
{
log.enterScope("testStatefulSel");
bool first = true;
var foo = new StatefulSelector(new BehaviorAction(delegate(){
return(BehaviorReturnCode.Failure);
}), new BehaviorAction(delegate() {
if (first)
{
first = false;
return(BehaviorReturnCode.Running);
}
else
{
return(BehaviorReturnCode.Failure);
}
}), new BehaviorAction(delegate(){
return(BehaviorReturnCode.Success);
}));
new VerificationPoint().VerifyEquals("1st running", true, foo.Behave(), BehaviorReturnCode.Running);
new VerificationPoint().VerifyEquals("2nd success", true, foo.Behave(), BehaviorReturnCode.Success);
new VerificationPoint().VerifyEquals("3rd success", true, foo.Behave(), BehaviorReturnCode.Success);
log.logMessage("restting first");
first = true;
new VerificationPoint().VerifyEquals("after reset running", true, foo.Behave(), BehaviorReturnCode.Running);
new VerificationPoint().VerifyEquals("final success", true, foo.Behave(), BehaviorReturnCode.Success);
log.exitScope();
}
public void When_Failed_then_execute_until_success()
{
var returnCode = new StatefulSelector(
new BehaviourAction(CalledAndFailed),
new BehaviourAction(CalledAndFailed),
new BehaviourAction(() => BehaviourReturnCode.Success)
).Behave();
Assert.AreEqual(2, _calledAndFailedTimes);
Assert.AreEqual(BehaviourReturnCode.Success, returnCode);
}
private StatefulSequence CalculatePath(System.Func <BehaviorReturnCode> calcPathStratigie)
{
BehaviorAction updateMemory = new BehaviorAction(aiToTarget.UpdateMemory);
BehaviorAction calculatePath = new BehaviorAction(calcPathStratigie);
BehaviorAction updateMemoryAdditional = new BehaviorAction(aiToTarget.UpdateMemoryWithAdditionalRange);
StatefulSequence calcNewPath = new StatefulSequence(updateMemoryAdditional, calculatePath);
StatefulSelector calculatePathSecure = new StatefulSelector(calculatePath, calcNewPath);
return(new StatefulSequence(updateMemory, calculatePathSecure));
}
public void When_behave_Running_then_completes_until_running_behaviour()
{
_calledAndFailedTimes = 0;
var returnCode = new StatefulSelector(
new BehaviourAction(CalledAndFailed),
new BehaviourAction(CalledAndRunning),
new BehaviourAction(() => BehaviourReturnCode.Success)
).Behave();
Assert.AreEqual(1, _calledAndFailedTimes);
Assert.AreEqual(BehaviourReturnCode.Running, returnCode);
}
public void testStatefulSel()
{
_log.enterScope("testStatefulSel");
bool first = true;
bool second = true;
var foo = new StatefulSelector(new BehaviorAction(delegate(){
return(BehaviorReturnCode.Failure);
}), new BehaviorAction(delegate() {
if (first)
{
first = false;
return(BehaviorReturnCode.Running);
}
else
{
return(BehaviorReturnCode.Failure);
}
}), new BehaviorAction(delegate(){
if (first)
{
return(BehaviorReturnCode.Success);
}
else
{
if (second)
{
second = false;
return(BehaviorReturnCode.Success);
}
else
{
return(BehaviorReturnCode.Failure);
}
}
}));
Verify.VerifyEquals("1st running", true, foo.Behave(), BehaviorReturnCode.Running);
Verify.VerifyEquals("2nd success", true, foo.Behave(), BehaviorReturnCode.Success);
Verify.VerifyEquals("3rd failure", true, foo.Behave(), BehaviorReturnCode.Failure);
_log.logMessage("restting flags");
first = true;
second = true;
Verify.VerifyEquals("after reset running", true, foo.Behave(), BehaviorReturnCode.Running);
Verify.VerifyEquals("final success", true, foo.Behave(), BehaviorReturnCode.Success);
Verify.VerifyEquals("final failure", true, foo.Behave(), BehaviorReturnCode.Failure);
_log.exitScope();
}
public void When_running_Then_complete_with_many_behave_calls()
{
var sequence = new StatefulSelector(
new BehaviourAction(CalledAndFailed),
new BehaviourAction(new TestHelper().RunningTwiceThenSuccess),
new BehaviourAction(() => BehaviourReturnCode.Success)
);
Assert.AreEqual(BehaviourReturnCode.Running, sequence.Behave());
Assert.AreEqual(BehaviourReturnCode.Running, sequence.Behave());
Assert.AreEqual(BehaviourReturnCode.Running, sequence.Behave());
Assert.AreEqual(BehaviourReturnCode.Success, sequence.Behave());
Assert.AreEqual(1, _calledAndFailedTimes);
}
private Sequence DefensiveAI()
{
Conditional targetAlive = new Conditional(aiWeapon.TargetAlive);
Conditional aiIsOnTransitionOrDodge = new Conditional(aiToTarget.OnTransitionOrDodge);
Conditional isBreakValid = new Conditional(aiToTarget.IsBreakValid);
Conditional canIShoot = new Conditional(aiWeapon.IsTargetHittable);
Selector shootSelect = new Selector(new Inverter(targetAlive), canIShoot, aiIsOnTransitionOrDodge);
StatefulSelector stayOrMove = new StatefulSelector(isBreakValid, DoTransitionBehavior());
Sequence shootAndOrMove = new Sequence(stayOrMove, shootSelect);
RepeatUntilFail followPathLoop = new RepeatUntilFail(shootAndOrMove);
return(new Sequence(new Sequence(Dodge(), Shoot()), new StatefulSequence(CalculatePath(aiToTarget.CalculatePathToUpperNode), followPathLoop)));
}
public void TestStatefulSel()
{
bool first = true;
bool second = true;
var foo = new StatefulSelector(new BehaviorAction(delegate(){
return(BehaviorReturnCode.Failure);
}), new BehaviorAction(delegate() {
if (first)
{
first = false;
return(BehaviorReturnCode.Running);
}
else
{
return(BehaviorReturnCode.Failure);
}
}), new BehaviorAction(delegate(){
if (first)
{
return(BehaviorReturnCode.Success);
}
else
{
if (second)
{
second = false;
return(BehaviorReturnCode.Success);
}
else
{
return(BehaviorReturnCode.Failure);
}
}
}));
Assert.That(foo.Behave() == BehaviorReturnCode.Running);
Assert.That(foo.Behave() == BehaviorReturnCode.Success);
Assert.That(foo.Behave() == BehaviorReturnCode.Failure);
first = true;
second = true;
Assert.That(foo.Behave() == BehaviorReturnCode.Running);
Assert.That(foo.Behave() == BehaviorReturnCode.Success);
Assert.That(foo.Behave() == BehaviorReturnCode.Failure);
}
private StatefulSequence DoTransitionBehavior()
{
BehaviorAction move = new BehaviorAction(aiToTarget.Move);
Conditional stopped = new Conditional(aiToTarget.StoppedCheck);
BehaviorAction fail = new BehaviorAction(ReturnFail);
BehaviorAction respawn = new BehaviorAction(aiToTarget.Respawn);
BehaviorAction die = new BehaviorAction(Die);
BehaviorAction nextTransition = new BehaviorAction(aiToTarget.NextTransition);
BehaviorAction waitForGrounded = new BehaviorAction(ReturnRunning);
Sequence stopOrMove = new Sequence(new Inverter(stopped), move);
StatefulSelector fallingBehavior = new StatefulSelector(respawn, die);
IndexSelector fallingOrStanding = new IndexSelector(FallOrStandSelect, fail, fallingBehavior, waitForGrounded);
StatefulSelector moveSelect = new StatefulSelector(stopOrMove, fallingOrStanding);
return(new StatefulSequence(nextTransition, moveSelect));
}
public void StatefulSelector()
{
var first = true;
var second = true;
var statefulSelector =
new StatefulSelector(
new BehaviorAction(() => BehaviorState.Failure),
new BehaviorAction(() =>
{
if (first)
{
first = false;
return(BehaviorState.Running);
}
return(BehaviorState.Failure);
}),
new BehaviorAction(() =>
{
if (first)
{
return(BehaviorState.Success);
}
if (second)
{
second = false;
return(BehaviorState.Success);
}
return(BehaviorState.Failure);
})
);
var statefulSelectorError =
new StatefulSelector(
new BehaviorAction(() => { throw new Exception("Failure"); })
);
// test init
Assert.IsTrue(first, "init first");
Assert.IsTrue(second, "init second");
Assert.AreEqual(statefulSelector.Tick(), BehaviorState.Running, "1st running");
Assert.IsFalse(first, "1st Tick failed");
Assert.AreEqual(statefulSelector.Tick(), BehaviorState.Success, "2nd success");
Assert.IsFalse(second, "2nd Tick failed");
Assert.AreEqual(statefulSelector.Tick(), BehaviorState.Failure, "3rd failure");
first = true;
second = true;
// test reset
Assert.IsTrue(first, "reset first");
Assert.IsTrue(second, "reset second");
Assert.AreEqual(statefulSelector.Tick(), BehaviorState.Running, "1st running");
Assert.IsFalse(first, "1st Tick failed");
Assert.AreEqual(statefulSelector.Tick(), BehaviorState.Success, "2nd success");
Assert.IsFalse(second, "2nd Tick failed");
Assert.AreEqual(statefulSelector.Tick(), BehaviorState.Failure, "3rd failure");
// test exception
Assert.AreEqual(statefulSelectorError.Tick(), BehaviorState.Failure, "error failure");
Assert.AreEqual(statefulSelectorError.LastBehavior, 0);
}
