Esempio n. 1
0
        /// <summary>
        /// Decomposes and schedules the transition between current state and target state.
        /// </summary>
        public List<HTNTaskSet> DecomposeTaskSet(
            ResourceProfileSet resourceProfileSet,
            SpecificationKnowledge specificationKnowledge,
            ComplexHTNPlanner htnPlanner,
            HTNState currentHTNState,
            HTNState targetHTNState)
        {
            List<List<HTNTaskSet>> allNewDecomposedTaskSetList = new List<List<HTNTaskSet>>();
            HTNState currentState = currentHTNState;
            int longestSize = 1;

            // Start to decompose
            foreach (string taskID in TaskIDList)
            {
                // If the task needs to be decomposed, decompose it
                if (!specificationKnowledge.IsTaskAPrimitive(taskID))
                {
                    HTNMethod method = htnPlanner.FindASuitableMethodOrOperator(taskID, currentState);

                    HTNTaskNetwork decomposedTaskNetwork = specificationKnowledge.GetTaskNetwork(method.TaskNetworkID);
                    int constraintsCount = decomposedTaskNetwork.Constraints.Count;

                    Random random = new Random();
                    int selectedConstraint = random.Next(0, constraintsCount);
                    HTNTaskNetworkConstraints htnTaskNetworkConstraints
                        = decomposedTaskNetwork.Constraints.ElementAt(selectedConstraint).Value;

                    List<HTNTaskSet> decomposedTaskSetList = htnTaskNetworkConstraints.HTNTaskConstraints;
                    if (decomposedTaskSetList.Count > longestSize)
                    {
                        longestSize = decomposedTaskSetList.Count;
                    }

                    string resourceID = TaskExecutors[taskID];
                    foreach (HTNTaskSet decomposedHTNTask in decomposedTaskSetList)
                    {
                        foreach (string subTaskID in decomposedHTNTask.TaskIDList)
                        {
                            decomposedHTNTask.TaskExecutors.Add(subTaskID, resourceID);
                        }
                    }

                    allNewDecomposedTaskSetList.Add(decomposedTaskSetList);
                }
                // The task is primitive so does not need to be decomposed further
                else
                {
                    List<HTNTaskSet> decomposedTaskSetList = new List<HTNTaskSet>();
                    HTNTaskSet htnTaskSet = new HTNTaskSet();

                    string resourceID = TaskExecutors[taskID];

                    htnTaskSet.TaskExecutors.Add(taskID, resourceID);
                    htnTaskSet.TaskIDList.Add(taskID);

                    decomposedTaskSetList.Add(htnTaskSet);
                    allNewDecomposedTaskSetList.Add(decomposedTaskSetList);
                }
            }
            // end of decomposing

            // Schedule all tasks into a single list of task sets

            List<HTNTaskSet> mergeredHTNSetList = new List<HTNTaskSet>();
            for (int i = 0; i < longestSize; i++)
            {
                HTNTaskSet newlyMergeredHTNTaskSet = new HTNTaskSet();

                foreach (List<HTNTaskSet> htnTaskSetList in allNewDecomposedTaskSetList)
                {
                    if (htnTaskSetList.Count > i)
                    {
                        foreach (string taskID in htnTaskSetList[i].TaskIDList)
                        {
                            string resourceID = htnTaskSetList[i].TaskExecutors[taskID];

                            newlyMergeredHTNTaskSet.TaskExecutors.Add(taskID, resourceID);
                            newlyMergeredHTNTaskSet.AddTaskID(taskID);

                        }
                    }
                }
                mergeredHTNSetList.Add(newlyMergeredHTNTaskSet);
            }

            return mergeredHTNSetList;
        }