public async Task CookScenario()
{
var pool = CreateResourcePool();
var provider = new WorldStateProvider();
var planner = PlannerFactory.CreatePlanner();
var actionSet = new ActionSet(GetDomainActions(pool, provider));
var ingredients = new[] { Ingredient.CookedPatty, Ingredient.Bread, Ingredient.Cheese };
var tasks = new List <Task>();
var executedActions = new List <string>();
foreach (var ingredient in ingredients)
{
var goalState = DomainState.Empty.Set(ingredient + "Delivered", true);
var result = planner.GetPlan(provider.GetCurrentState(null), goalState, actionSet);
Assert.True(result.Success);
tasks.Add(RunPlan(result.Plan, executedActions));
}
await Task.WhenAll(tasks);
Assert.NotEmpty(executedActions);
Assert.Equal("Starting: Pick Up RawPatty", executedActions.First());
}
public async Task ShouldThrowExceptionIfNoGoalsSupplied()
{
var planner = PlannerFactory.CreatePlanner();
var agent = new Agent(planner);
await Assert.ThrowsAsync<InvalidOperationException>(
async () => await agent.RunActionsAsync());
}
public async Task BindableActionsShouldBeAvailable()
{
var planner = PlannerFactory.CreatePlanner();
var agent = new TestAgent(planner);
await Assert.ThrowsAsync<NoRunException>(
async () => await agent.RunActionsAsync());
}
public async Task ShouldUseFallbackGoal()
{
var goal = new TestGoal{Weight = 1};
var planner = PlannerFactory.CreatePlanner();
var agent = new FallbackAgent(planner, goal);
await Assert.ThrowsAsync<InvalidOperationException>(
async () => await agent.RunActionsAsync());
Assert.Equal(goal, agent.CurrentGoal);
}
public async Task ShouldRunActionToReachGoal()
{
var goal = new TestGoal{Weight = 1};
var planner = PlannerFactory.CreatePlanner();
var agent = new FallbackAgent(planner, goal);
agent.AddGoal(goal);
agent.AddAction(new NoRunAction());
await Assert.ThrowsAsync<NoRunException>(
async () => await agent.RunActionsAsync());
}
public void FailedPlanningShouldReturnNullPlan()
{
var start = DomainState.Empty;
var target = DomainState.Empty.Set("test", 123);
var actions = new ActionSet(Enumerable.Empty <IDomainAction>());
var planner = PlannerFactory.CreatePlanner();
var result = planner.GetPlan(start, target, actions);
Assert.False(result.Success);
Assert.Null(result.Plan);
Assert.Null(result.SearchTree);
}
public async Task ShouldChooseHighestRatedGoal()
{
var planner = PlannerFactory.CreatePlanner();
var agent = new Agent(planner);
var goal1 = new TestGoal{Weight = 0.2f};
var goal2 = new TestGoal{Weight = 0.5f};
agent.AddGoal(goal1);
agent.AddGoal(goal2);
await Assert.ThrowsAsync<InvalidOperationException>(
async() => await agent.RunActionsAsync());
Assert.Equal(goal2, agent.CurrentGoal);
}
public async Task ShouldUseConsiderationToChooseBestGoal()
{
var planner = PlannerFactory.CreatePlanner();
var agent = new Agent(planner);
var goal1 = new TestGoal{Weight = 1};
var goal2 = new TestGoal{Weight = 1};
goal1.AddConsideration(Consideration.FromFunc(d => 0.5f));
goal2.AddConsideration(Consideration.FromFunc(d => 0.2f));
agent.AddGoal(goal1);
agent.AddGoal(goal2);
await Assert.ThrowsAsync<InvalidOperationException>(
async() => await agent.RunActionsAsync());
Assert.Equal(goal1, agent.CurrentGoal);
}
public async Task CancellationOfRunningActionsShouldWork()
{
var goal = new TestGoal{Weight = 1};
var action = new InfiniteRunAction();
var planner = PlannerFactory.CreatePlanner();
var agent = new Agent(planner);
var source = new CancellationTokenSource();
agent.AddGoal(goal);
agent.AddAction(action);
var agentTask = agent.RunActionsAsync(source.Token);
var cancelTask = Task.Run(() => source.Cancel());
await Task.WhenAll(agentTask, cancelTask);
Assert.Equal(action, agent.CurrentAction);
}
public void PlanningShouldFindWayToReachTargetValue()
{
var actionList = new List <IDomainAction>
{
new BuyAction("Axe"),
new SellAction("Wood"),
new EatPieAction(),
new BuyAction("Pie"),
new ChopWoodAction(),
new TakeANapAction(),
new GoToAction("Shop"),
new GoToAction("Tree"),
new GoToAction("Home"),
new BuyAction("Alcohol"),
new DrinkAlcoholAction()
};
var actions = new ActionSet(actionList);
var start = DomainState.Empty
.Set("isHungry", true)
.Set("isSober", true)
.Set("hasAxe", true);
var goal = DomainState.Empty
.Set("isHungry", false)
.Set("isDrunk", true);
var planner = PlannerFactory.CreatePlanner(
new PlannerSettings
{
EarlyExit = false,
CreateDebugGraph = true,
PlannerType = PlannerType.Regressive
});
// WarmUp
// for (var i = 0; i < 10; i++)
// {
// var _ = planner.GetPlan(start, goal, actions);
// }
PlanningResult result = null;
var sw = Stopwatch.StartNew();
for (var i = 0; i < BenchmarkIterations; i++)
{
result = planner.GetPlan(start, goal, actions);
}
Assert.NotNull(result);
Assert.NotNull(result.Plan);
Assert.NotEmpty(result.Plan);
Assert.NotNull(result.SearchTree);
sw.Stop();
//WritePlanToFile(plan, sw);
}
