public void OperatorAddBindingTest() { testOperator.AddBinding("?taker", "frodo"); testOperator.AddBinding("?thing", "ring"); Assert.AreEqual("frodo", testOperator.TermAt(0)); Assert.AreEqual("ring", testOperator.TermAt(1)); Assert.AreEqual(testOperator.Bindings["?taker"], "frodo"); }
/// <summary> /// Given an event revision plan, along with its original domain and problem, returns an equivalent regular plan. /// </summary> /// <param name="plan">A plan with event revision steps.</param> /// <param name="domain">The original domain used to build the event revision.</param> /// <param name="problem">The original problem used to build the mediation tree.</param> /// <returns>A regular plan, equivalent to the output of event revision.</returns> public static Plan ReformatPlan(Plan plan, Domain domain, Problem problem) { // Create a list to hold the new plan steps. List <IOperator> newSteps = new List <IOperator>(); // Loop through the steps in the event revision plan. foreach (IOperator step in plan.Steps) { // Split the title according to the * token placeholder. string[] title = step.Name.Split('*'); // Find the operator template in the original domain that matches the event revision action. Operator template = new Operator("do-nothing"); if (!title[0].Equals("do-nothing")) { template = domain.Operators.Find(x => x.Name.Equals(title[0])).Template() as Operator; } // If this is a proper event revision action... if (title.Length > 1) { // If this was an observed action... if (title.Length - 1 == template.Arity) { // Loop through each of the template's terms... for (int i = 0; i < template.Arity; i++) { // And bind the variable to the constant listed in the title. template.AddBinding(template.TermAt(i), title[i + 1]); } } // If this was an unobserved action... else { // Bind the action's actor using the title. template.AddBinding(template.TermAt(0), title[1]); // Then loop through each of the template's terms... for (int i = 1; i < template.Arity; i++) { // And bind the variable using the corresponding constant in the action. template.AddBinding(template.TermAt(i), step.TermAt(i)); } } } // If this is not an event revision action, just clone it. else { template = step.Clone() as Operator; } // Add the translated action to the set of actions. newSteps.Add(template); } // Create a new plan object using the new set of actions and return it. return(new Plan(domain, problem, newSteps)); }
// The plan already has this step. public List <IPlan> Process(IPlan planToBuildOn) { // Operator step = planToBuildOn.Find(HasTerm).Action as Operator; // Check if if (step.TermAt(PositionOfTerm).Equals(TermToHave)) { return(new List <IPlan>() { planToBuildOn }); } else { var t = step.TermAt(PositionOfTerm); step.AddBinding(t, TermToHave.Constant); } var newPlans = new List <IPlan>(); //foreach (var precon in thisConstraint.Second.Preconditions) //{ // if (CacheMaps.IsCndt(precon, thisConstraint.First)) // { // var planClone = planToBuildOn.Clone() as IPlan; // planClone.CausalLinks.Add(new CausalLink<IPlanStep>(precon, thisConstraint.First, thisConstraint.Second)); // newPlans.Add(planClone); // } //} return(newPlans); }
public static IOperator AddPreconditionsAndEffects(Operator opToken, Domain domain) { foreach (var op in domain.Operators) { if (!opToken.Name.Equals(op.Name)) { continue; } for (int i = 0; i < op.Terms.Count; i++) { var term = opToken.Terms[i]; term.Variable = op.Terms[i].Variable; opToken.AddBinding(term.Variable, term.Constant); } var groundOperator = new Operator(opToken.Name, opToken.Terms, opToken.Bindings, op.Preconditions.ToList(), op.Effects.ToList()); groundOperator.UpdateBindings(); // Check to see if bindings are propagated to preconditiosn and effects Console.Write(groundOperator); return(groundOperator as IOperator); } return(null); }