public List<HTNTaskSet> AssignAndRefineTaskSet( ResourceProfileSet resourceSet, HTNState currentHTNState, HTNState targetHTNState, SpecificationKnowledge specificationKnowledge) { List<HTNTaskSet> newRefinedHTNTaskSetList = new List<HTNTaskSet>(); List<string> waitingTaskList = new List<string>(); foreach (string taskID in this.TaskIDList) { waitingTaskList.Add(taskID); } while (waitingTaskList.Count > 0) { List<string> allocatedResourceIDList = new List<string>(); List<string> allocatedTaskIDList = new List<string>(); List<bool> resourceAllocatedIndicator = new List<bool>(); HTNTaskSet htnTaskSet = new HTNTaskSet(); for (int i = 0; i < resourceSet.Resources.Count; i++) { resourceAllocatedIndicator.Add(true); } foreach (string taskID in waitingTaskList) { for (int i = 0; i < resourceSet.Resources.Count; i++) { ResourceProfile ra = resourceSet.Resources[i]; if (resourceAllocatedIndicator[i] && ra.CanExecuteThisTask(taskID)) { resourceAllocatedIndicator[i] = false; htnTaskSet.AddTaskID(taskID); htnTaskSet.TaskExecutors.Add(taskID, ra.ID); allocatedTaskIDList.Add(taskID); // added to prevent the re-added value break; } } } foreach (string taskID in allocatedTaskIDList) { waitingTaskList.Remove(taskID); } newRefinedHTNTaskSetList.Add(htnTaskSet); } return newRefinedHTNTaskSetList; }
public ComplexHTNPlanner() { InitialState = new HTNState(); TargetState = new HTNState(); TaskNetwork = new HTNTaskNetwork(); StateConstraints = new List<HTNState>(); TaskSets = new List<HTNTaskSet>(); AllocationDictionary = new Dictionary<string, string>(); ResourceProfileSet = new ResourceProfileSet(); }
public HTNState(HTNState htnState) : this() { PlanningDomain = htnState.PlanningDomain; foreach (KeyValuePair<string, string> kvp in this.States) { States.Remove(kvp.Key); } foreach (KeyValuePair<string, string> kvp in htnState.States) { string key = new string(kvp.Key.ToCharArray()); string value = new string(kvp.Value.ToCharArray()); States.Add(key, value); } }
/// <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; }
public abstract void SetPlannerProperties( HTNState initialHTNState, HTNState targetHTNState, string workitemID, SpecificationKnowledge specificationKnowledge, ResourceProfileSet resourceProfileSet);
public void AddTargetState(HTNState targetState) { this.targetState = targetState; }
public void AddInitialState(HTNState initialState) { this.initialState = initialState; }
public HTNMethod FindASuitableMethodOrOperator(string taskID, HTNState currentState) { Dictionary<string, HTNMethod> methodDictionary = SpecificationKnowledge.GetMethodDictionary(); List<string> candidateMethodList = new List<string>(); foreach (KeyValuePair<string, HTNMethod> pvMethod in methodDictionary) { if (pvMethod.Value.SuitsAMethod(taskID, currentState) && pvMethod.Value.CurrentStateSatisifyMethodPrecondition(currentState)) candidateMethodList.Add(pvMethod.Key); } if (candidateMethodList.Count == 0) return null; return SpecificationKnowledge.GetMethodDictionary()[candidateMethodList[0]]; }
private HTNMethod SelectAMethodForThisWorkitem(string key, HTNState currentState) { List<HTNMethod> suitableMethod = new List<HTNMethod>(); foreach (KeyValuePair<string, HTNMethod> pv in SpecificationKnowledge.GetMethodDictionary()) { HTNMethod method = pv.Value; if (method.SuitsAMethod(key, currentState)) suitableMethod.Add(method); } int count = suitableMethod.Count; HTNMethod selectMethod = null; if (count >= 1) { Random randObj = new Random(); int select = randObj.Next(0, count); selectMethod = suitableMethod[select]; } return selectMethod; }
// TODO: JUST HAD A BRILLIANT IDEA FOR A METHOD GUYS public bool ContainsThisState(HTNState htnState) { return false; }
// TODO This appears to not be implemented ffs. public bool CurrentStateSatisifyMethodPrecondition(HTNState currentState) { return true; }
public override List<HTNTaskSet> GeneratePlan() { // Select a task network for the workitem HTNMethod htnMethod = SelectAMethodForThisWorkitem(WorkitemID, InitialState); if (htnMethod == null) { Console.WriteLine("Method undefined. Unable to generate a plan."); return null; } string taskNetworkID = htnMethod.TaskNetworkID; HTNTaskNetwork htnTaskNetwork = SpecificationKnowledge.GetTaskNetwork(taskNetworkID); HTNTaskNetworkConstraints constraint = htnTaskNetwork.Constraints[FirstConstraint]; TaskSets = constraint.HTNTaskConstraints; for (int i = 1; i < constraint.StateConstraints.Count - 1; i++) { StateConstraints.Insert(i, constraint.StateConstraints[i]); } // Perform Decomposition bool allPrimitive = false; bool allScheduled = false; while (!allPrimitive && !allScheduled) { // extend the current task network, assign some tasks to resources, generate more states List<HTNTaskSet> newHTNTaskSetList = new List<HTNTaskSet>(); for (int i = 0; i < TaskSets.Count; i++) { HTNTaskSet htnTaskSet = TaskSets[i]; List<HTNTaskSet> newHTNSetFragment = htnTaskSet. AssignAndRefineTaskSet( ResourceProfileSet, StateConstraints[i], StateConstraints[i + 1], SpecificationKnowledge ); foreach (HTNTaskSet newHTNTaskSet in newHTNSetFragment) { newHTNTaskSetList.Add(newHTNTaskSet); } } TaskSets = newHTNTaskSetList; List<HTNState> newHTNStateList = new List<HTNState>(); newHTNStateList.Add(InitialState); newHTNStateList.Add(TargetState); HTNState localHTNState = new HTNState(InitialState); for (int i = 0; i < TaskSets.Count - 1; i++) { HTNState deducedState = localHTNState.DeduceNextStateBasedOnEffects( TaskSets[i].GetAllPostEffects(SpecificationKnowledge)); localHTNState = new HTNState(deducedState); newHTNStateList.Insert(i + 1, deducedState); } StateConstraints = newHTNStateList; // Attempt to decompose List<HTNTaskSet> newlyDecomposedHTNTaskSetList = new List<HTNTaskSet>(); for (int i = 0; i < TaskSets.Count; i++) { HTNTaskSet htnTaskSet = TaskSets[i]; List<HTNTaskSet> partialDecomposedHTNTaskSetList = htnTaskSet.DecomposeTaskSet( ResourceProfileSet, SpecificationKnowledge, this, StateConstraints[i], StateConstraints[i + 1] ); foreach (HTNTaskSet taskSet in partialDecomposedHTNTaskSetList) { newlyDecomposedHTNTaskSetList.Add(taskSet); } } allScheduled = true; TaskSets = newlyDecomposedHTNTaskSetList; // TODO: Hope this doesn't break. Dammit.. allPrimitive = AreAllTasksPrimitive(TaskSets); //foreach (HTNTaskSet htnTaskSet in TaskSets) //{ // foreach (string taskID in htnTaskSet.TaskIDList) // { // if (!SpecificationKnowledge.IsTaskAPrimitive(taskID)) // { // allPrimitive = false; // } // } // if (!allPrimitive) // { // break; // } //} if (!allPrimitive && allScheduled) { newHTNStateList.Clear(); newHTNStateList.Add(InitialState); newHTNStateList.Add(TargetState); localHTNState = new HTNState(InitialState); for (int i = 0; i < TaskSets.Count - 1; i++) { HTNState deduced_state = localHTNState.DeduceNextStateBasedOnEffects(TaskSets[i].GetAllPostEffects(SpecificationKnowledge)); localHTNState = new HTNState(deduced_state); newHTNStateList.Insert(i + 1, deduced_state); } this.StateConstraints = newHTNStateList; allPrimitive = false; } allScheduled = true; foreach (HTNTaskSet htnTaskSet in TaskSets) { if (!htnTaskSet.IsScheduled()) { allScheduled = false; } } } int stateSize = StateConstraints.Count; for (int i = 0; i < StateConstraints.Count; i++) { HTNState htnState = new HTNState(StateConstraints[i]); foreach (KeyValuePair<string, string> kvp1 in htnState.States) { Console.ForegroundColor = ConsoleColor.Green; Console.Write("state_name: " + kvp1.Key); Console.ForegroundColor = ConsoleColor.Red; Console.WriteLine(" state_value: " + kvp1.Value); } if (i < stateSize - 1) { Console.ForegroundColor = ConsoleColor.Yellow; HTNTaskSet htnTaskSet = new HTNTaskSet(TaskSets[i]); foreach (KeyValuePair<string, string> kvp2 in htnTaskSet.TaskExecutors) { Console.WriteLine("task_id: " + kvp2.Key + " " + "executor: " + kvp2.Value); } } } return TaskSets; }
public bool IsEqualTo(HTNState antherState) { if (antherState.StateAtoms.Count > this.StateAtoms.Count || this.StateAtoms.Count > antherState.StateAtoms.Count) { return false; } foreach (string state in antherState.StateAtoms) { if (!this.StateAtoms.Contains(state)) return false; } return true; }
public bool HasSameStates(HTNState inputState) { int lengthOfThis = this.StateAtoms.Count; int lengthOfInput = inputState.StateAtoms.Count; List<string> baseStateSet; List<string> otherStateSet; if (lengthOfThis > lengthOfInput) { baseStateSet = this.StateAtoms; otherStateSet = inputState.StateAtoms; } else { baseStateSet = inputState.StateAtoms; otherStateSet = this.StateAtoms; } foreach (string state in otherStateSet) { if (!baseStateSet.Contains(state)) { return false; } } return true; }
public HTNState DeduceNextStateBasedOnEffects(List<HTNEffect> effectList) { HTNState nextState = new HTNState(this); foreach (HTNEffect htnEffect in effectList) { nextState.States[htnEffect.StateAtomName] = htnEffect.StateAtomValue; } return nextState; }
private bool DeduceFollowingStates( IEnumerable<HTNTaskSet> refinedHTNTaskSetList, HTNState currentState, HTNState targetState, SpecificationKnowledge specificationKnowledge) { List<HTNState> newlyDeducedHTNStateList = new List<HTNState>(); newlyDeducedHTNStateList.Add(currentState); HTNState localCurrentHTNState = new HTNState(currentState); List<List<HTNEffect>> htnEffectList = new List<List<HTNEffect>>(); foreach (HTNTaskSet htnTaskSet in refinedHTNTaskSetList) { List<HTNEffect> postEffects = new List<HTNEffect>(); foreach (string taskID in htnTaskSet.TaskIDList) { HTNTask htnTask = specificationKnowledge.GetHTNTask(taskID); postEffects.AddRange(htnTask.PostConditions); } htnEffectList.Add(postEffects); } HTNState nextHTNState = null; foreach (List<HTNEffect> htnEffects in htnEffectList) { nextHTNState = new HTNState(localCurrentHTNState.DeduceNextStateBasedOnEffects(htnEffects)); newlyDeducedHTNStateList.Add(nextHTNState); } if (nextHTNState != null && nextHTNState.IsEqualTo(targetState)) { newlyDeducedHTNStateList.Remove(nextHTNState); RefinedStateList = newlyDeducedHTNStateList; return true; } return false; }
public override void SetPlannerProperties( HTNState initialHTNState, HTNState targetHTNState, string workitemID, SpecificationKnowledge specificationKnowledge, ResourceProfileSet resourceProfileSet) { ResourceProfileSet = resourceProfileSet; SpecificationKnowledge = specificationKnowledge; StateConstraints.Clear(); StateConstraints.Add(initialHTNState); StateConstraints.Add(targetHTNState); InitialState.StateAtoms.Clear(); InitialState = new HTNState(initialHTNState); TargetState = new HTNState(targetHTNState); WorkitemID = workitemID; }
public override void SetPlannerProperties(HTNState initialHTNState, HTNState targetHTNState, string workitemID, SpecificationKnowledge specificationKnowledge, ResourceProfileSet resourceProfileSet) { throw new NotImplementedException(); }
public bool SuitsAMethod(string taskID, HTNState htnState) { if (TaskID.Equals(taskID) && htnState.IsThisAViolatingEffect(PreConditions)) return true; return false; }