jshop2.java

SHOP2 一个人工智能里面关于任务分解和任务规划的系统。JSHOP2是其java版本。

        PlanStepInfo newStep = new PlanStepInfo();
        newStep.planFound = true;
        planStepList.add(newStep);
        numPlans++;

        return true;
      }
    }

    //-- This array of size 4 will store the atoms and protections that are
    //-- deleted from and added to the current state of the world as a result
    //-- of an operator being applied. This information is used in case a
    //-- backtrack happens over that operator to store the state of the world
    //-- to what it was before the backtracked operator was applied.
    v.delAdd = new Vector[4];

    //-- To iterate over the tasks we have the option to achieve right now.
    v.e = v.t0.iterator();

    //-- For each of the tasks that we have the option to achieve right now,
    while (v.e.hasNext())
    {
      //-- Find the next option.
      v.tl = (TaskList)v.e.next();
      v.t = v.tl.getTask();

      //-- Create a TRYING step for the list of plan steps
      PlanStepInfo newStep = new PlanStepInfo();
      newStep.action = "TRYING";
      newStep.state = state.getState();
      newStep.taskAtom = v.t;
      planStepList.add(newStep);

      //-- If that task is primitive,
      if (v.t.isPrimitive())
      {
        //-- Remove the task from the task list, by replacing it with an empty
        //-- task list.
        v.tl.replace(TaskList.empty);

        //-- Find all the operators that achieve this primitive task.
        v.o = domain.ops[v.t.getHead().getHead()];

        //-- For each of these operators,
        for (v.j = 0; v.j < v.o.length; v.j++)
        {
          //-- Find the binding that unifies the head of the operator with the
          //-- task.
          v.binding = v.o[v.j].unify(v.t.getHead());

          //-- If there is such bindings,
          if (v.binding != null)
          {
            //-- Get the iterator that iterates over all the bindings that can
            //-- satisfy the precondition for this operator.
            v.p = v.o[v.j].getIterator(v.binding, 0);

            //-- For each such binding,
            while ((v.nextB = v.p.nextBinding()) != null)
            {
              //-- Merge the two bindings.
              Term.merge(v.nextB, v.binding);

              //-- If the operator is applicable, apply it, and,
              if (v.o[v.j].apply(v.nextB, state, v.delAdd))
              {
                //-- Add the instance of the operator that achieved this task
                //-- to the beginning of the plan, remembering how much it
                //-- cost.
                double cost = currentPlan.addOperator(v.o[v.j], v.nextB);

                //-- Create a STATECHANGED step for the list of plan steps
                newStep = new PlanStepInfo();
                newStep.action = "STATECHANGED";
                newStep.taskAtom = v.t;
                newStep.delAdd = v.delAdd;
                newStep.operatorInstance = v.o[v.j].getHead().applySubstitution(v.nextB).toString(JSHOP2.getDomain().getPrimitiveTasks());
                planStepList.add(newStep);

                //-- Recursively call the same function to achieve the
                //-- remaining tasks. If a plan is found for the remaining
                //-- tasks and we have found the maximum number of plans we are
                //-- allowed, return true.
                if (findPlanHelper(tasks) && plans.size() >= planNo)
                  return true;

                //-- Remove the operator from the current plan.
                currentPlan.removeOperator(cost);
              }

              //-- Undo the changes that were the result of applying this
              //-- operator, because we are backtracking here.
              state.undo(v.delAdd);
            }
          }
        }

        //-- Insert the task we chose to achieve first back where it was,
        //-- because we couldn't achieve it.
        v.tl.undo();
      }
      //-- If that task is compound,
      else
      {
        //-- Find all the methods that decompose this compound task.
        v.m = domain.methods[v.t.getHead().getHead()];

        //-- For each of these methods,
        for (v.j = 0; v.j < v.m.length; v.j++)
        {
          //-- Find the binding that unifies the head of the method with the
          //-- task.
          v.binding = v.m[v.j].unify(v.t.getHead());

          //-- If there is such binding,
          if (v.binding != null)
          {
            //-- Initially, precondition of no branch of this method has
            //-- already been satisfied, so set this variable to false.
            v.found = false;

            //-- Iterate on all the branches of this method. note the use of
            //-- 'v.found' in the condition for the 'for' loop. It is there
            //-- because of the semantics of the method branches in JSHOP2:
            //-- Second branch is considered only when there is no binding for
            //-- the first branch, the third branch is considered only when
            //-- there is no binding for the first and second branches, etc.
            for (v.k = 0; (v.k < v.m[v.j].getSubs().length) && !v.found; v.k++)
            {
              //-- Get the iterator that iterates over all the bindings that
              //-- can satisfy the precondition for this branch of this method.
              v.p = v.m[v.j].getIterator(v.binding, v.k);

              //-- For each such binding,
              while ((v.nextB = v.p.nextBinding()) != null)
              {
                //-- Merge the two bindings.
                Term.merge(v.nextB, v.binding);

                //-- Replace the decomposed task in task list with its
                //-- decomposition according to this branch of this method.
                v.tl.replace(v.m[v.j].getSubs()[v.k].bind(v.nextB));

                //-- Create a REDUCED step for the list of plan steps
                newStep = new PlanStepInfo();
                newStep.action = "REDUCED";
                newStep.taskAtom = v.t;
                newStep.children = v.tl.subtasks;
                newStep.ordered = v.m[v.j].getSubs()[v.k].isOrdered();
                newStep.method = v.m[v.j].getLabel(v.k);
                planStepList.add(newStep);

                //-- Recursively call the same function to achieve the
                //-- remaining tasks, but make the function choose its next
                //-- tasks to achieve to be the substasks of the task we just
                //-- decomposed, till an operator is seen and applied, or this
                //-- whole task is achieved without seeing an operator (i.e.,
                //-- this task was decomposed to an empty task list).
                if (findPlanHelper(v.tl) && plans.size() >= planNo)
                  //-- A full plan is found, return true.
                  return true;

                //-- The further branches of this method must NOT be considered
                //-- even if this branch fails because there has been at least
                //-- one satisfier for this branch of the method. Set this
                //-- variable to true to prevent the further branches of this
                //-- method from being considered.
                v.found = true;

                //-- Undo the changes in the task list, because this particular
                //-- decomposition failed.
                v.tl.undo();
              }
            }
          }
        }
      }

      //-- Create a BACKTRACKING step for the list of plan steps
      newStep = new PlanStepInfo();
      newStep.action = "BACKTRACKING";
      newStep.taskAtom = v.t;
      planStepList.add(newStep);
    }

    //-- Return false, because all the options were tried and none worked.
    return false;
  }

  /** This function returns the planning domain.
   *
   *  @return
   *          the current planning domain.
  */
  public static Domain getDomain()
  {
    return domain;
  }

  /** This function returns the current state of the world.
   *
   *  @return
   *          the current state of the world.
  */
  public static State getState()
  {
    return state;
  }

  /** This function is used to initialize the planning algorithm.
   *
   *  @param domainIn
   *          the planning domain.
   *  @param stateIn
   *          the initial state of the world.
  */
  public static void initialize(Domain domainIn, State stateIn)
  {
    domain = domainIn;
    state = stateIn;
  }
}