public int AddToAgenda(PlanNode planNode, int index, string indent)
{
Console.WriteLine(indent + "Dialogue.PlanGraph AddToAgenda " + planNode.Name);
int currIdx = this._agenda.IndexOf(planNode);
if (currIdx >= 0)
{
if (index > currIdx)
{
this._agenda.RemoveAt(currIdx);
this._agenda.Insert(index - 1, planNode);
return(index - 1);
}
else if (index < currIdx)
{
this._agenda.RemoveAt(currIdx);
this._agenda.Insert(index, planNode);
return(index);
}
else
{
return(index);
}
}
else
{
this._agenda.Insert(index, planNode);
return(index);
}
}
private bool _explainAnswer(PlanNode planNode, DialogueAct dlgAct, string indent)
{
Console.WriteLine(indent + "Dialogue.PlanGraph _explainAnswer " + planNode.Name);
if (planNode is ActionNode)
{
ActionNode actNode = (ActionNode)planNode;
if (actNode.ActType == "ID")
{
foreach (string phrase in dlgAct.SpeechContext.Keys)
{
Console.WriteLine("phrase=" + phrase);
Console.WriteLine("(ParamNode)actNode=" + actNode.Name);
Console.WriteLine("(ParamNode)actNode.Parent=" + ((ParamNode)actNode.Parent).Name);
if (phrase.ToLower() == ((ParamNode)actNode.Parent).Name.ToLower())
{
return(true);
}
if (phrase.ToLower() == ((ParamNode)actNode.Parent).ParamType.ToLower())
{
return(true);
}
}
}
}
Console.WriteLine(indent + "false");
return(false);
}
public ParamNode(string name, string paramType, bool multiple, string description="", PlanNode parent=null) : base(name, description, parent)
{
this._paramType = paramType;
this._multiple = multiple;
this._paramState = ParamState.Unknown;
this._subActions = new ArrayList();
this._values = new ArrayList();
}
public void ElaborateFromNode(PlanNode planNode, string indent)
{
if (planNode is ActionNode)
{
this._elaborateFromActionNode((ActionNode)planNode, indent + " ");
}
else if (planNode is ParamNode)
{
this._elaborateFromParamNode((ParamNode)planNode, indent + " ");
}
}
public ActionNode(string name, string actType, string complexity, string description="", PlanNode parent=null) : base(name, description, parent)
{
this._actType = actType;
this._complexity = complexity;
this._recipeId = -1;
this._actState = ActionState.Unknown;
this._agents = new ArrayList();
this._params = new ArrayList();
this._subActions = new ArrayList();
this._optional = false;
}
public int RemoveFromAgenda(PlanNode planNode, string indent)
{
Console.WriteLine(indent + "Dialogue.PlanGraph RemoveFromAgenda " + planNode.Name);
int index = this._agenda.IndexOf(planNode);
if (index >= 0)
{
this._agenda.RemoveAt(index);
this._history.Add(planNode);
}
return(index);
}
private bool _parentParamsRdy(PlanNode planNode, string indent)
{
Console.WriteLine(indent + "Dialogue/PlanGraph _parentParamsRdy " + planNode.Name);
bool paramsRdy = true; // check whether the previous params are ready
ActionNode actionNode = planNode.Parent as ActionNode;
if (actionNode != null)
{
Console.WriteLine(indent + "Parent: " + actionNode.Name);
foreach (ParamNode param in actionNode.Params)
{
Console.WriteLine(indent + "param: " + param.Name);
if (param.Name != planNode.Name)
{
Console.WriteLine(indent + "param:" + param.Name + " ParamState:" + param.ParamState);
if (param.ParamState != ParamState.Ready)
{
paramsRdy = false;
}
foreach (ActionNode subAct in param.SubActions)
{
Console.WriteLine(indent + "subAct:" + subAct.Name + " ActState:" + subAct.ActState);
if (subAct.ActState == ActionState.Executing)
{
paramsRdy = false;
break;
}
}
if (paramsRdy == false)
{
break;
}
}
else
{
break;
}
}
}
else
{
Console.WriteLine(indent + "Parent: is NULL");
}
return(paramsRdy);
}
private bool _explainFeedback(PlanNode planNode, DialogueAct dlgAct, string indent)
{
Console.WriteLine(indent + "Dialogue.PlanGraph _explainFeedback " + planNode.Name);
if (planNode is ActionNode)
{
ActionNode actNode = (ActionNode)planNode;
if (actNode.ActState == ActionState.Executing)
{
foreach (string phrase in dlgAct.SpeechContext.Keys)
{
if (phrase.ToLower() == actNode.Name.ToLower())
{
return(true);
}
}
}
}
return(false);
}
private bool _explainAffOrNeg(PlanNode planNode, DialogueAct dlgAct, string indent)
{
Console.WriteLine(indent + "Dialogue.PlanGraph _explainAffOrNeg " + planNode.Name);
if (planNode is ActionNode)
{
ActionNode actNode = (ActionNode)planNode;
if (actNode.ActType == "ID" && actNode.ActState == ActionState.Executing)
{
if (actNode.Parent != null && actNode.Parent is ParamNode)
{
ParamNode paramNode = actNode.Parent as ParamNode;
if (paramNode.ParamType == "boolean")
{
return(true);
}
}
}
}
return(false);
}
public int RemoveFromAgenda(PlanNode planNode)
{
int index = this._agenda.IndexOf(planNode);
if (index >= 0)
{
this._agenda.RemoveAt(index);
this._history.Add(planNode);
}
return index;
}
public int AddToAgenda(PlanNode planNode, int index)
{
int currIdx = this._agenda.IndexOf(planNode);
if (currIdx >= 0)
{
if (index > currIdx)
{
this._agenda.RemoveAt(currIdx);
this._agenda.Insert(index - 1, planNode);
return (index - 1);
}
else if (index < currIdx)
{
this._agenda.RemoveAt(currIdx);
this._agenda.Insert(index, planNode);
return index;
}
else
{
return index;
}
}
else
{
this._agenda.Insert(index, planNode);
return index;
}
}
private ActionNode _explainActionFromNode(PlanNode planNode, Hashtable tempAct, DialogueAct dlgAct)
{
if (planNode is ActionNode)
{
ActionNode actionNode = (ActionNode)planNode;
if (actionNode.Name.ToLower() == tempAct["name"].ToString().ToLower())
{
// If the action has not been initiated, initiate it and add the agent
if (actionNode.ActState == ActionState.Unknown)
{
actionNode.ActState = ActionState.Initiated;
}
if (actionNode.SearchAgent(dlgAct.Agent) == null)
{
actionNode.Agents.Add(dlgAct.Agent);
}
// If the action has been completed, or failed, start a new one, attached it to the same parent
if (actionNode.ActState == ActionState.Complete || actionNode.ActState == ActionState.Failed)
{
ActionNode newAction = new ActionNode((string)tempAct["name"], (string)tempAct["act_type"], (string)tempAct["complexity"], (string)tempAct["description"], actionNode.Parent);
newAction.Agents.Add(dlgAct.Agent);
newAction.ActState = ActionState.Initiated;
if (actionNode.Parent != null)
{
if (actionNode.Parent is ActionNode)
{
((ActionNode)(actionNode.Parent)).SubActions.Add(newAction);
}
else if (actionNode.Parent is ParamNode)
{
((ParamNode)(actionNode.Parent)).SubActions.Add(newAction);
}
}
return newAction;
}
return actionNode;
}
// search the params and subactions
foreach (ParamNode paramNode in actionNode.Params)
{
ActionNode actNode = this._explainActionFromNode(paramNode, tempAct, dlgAct);
if (actNode != null)
{
return actNode;
}
}
foreach (ActionNode subActNode in actionNode.SubActions)
{
ActionNode actNode = this._explainActionFromNode(subActNode, tempAct, dlgAct);
if (actNode != null)
{
return actNode;
}
}
}
else if (planNode is ParamNode)
{
ParamNode paramNode = (ParamNode)planNode;
foreach (ActionNode subActNode in paramNode.SubActions)
{
ActionNode actNode = this._explainActionFromNode(subActNode, tempAct, dlgAct);
if (actNode != null)
{
return actNode;
}
}
}
return null;
}
private bool _explainFeedback(PlanNode planNode, DialogueAct dlgAct)
{
if (planNode is ActionNode)
{
ActionNode actNode = (ActionNode)planNode;
if (actNode.ActState == ActionState.Executing)
{
foreach (string phrase in dlgAct.SpeechContext.Keys)
{
if (phrase.ToLower() == actNode.Name.ToLower())
{
return true;
}
}
}
}
return false;
}
private bool _explainAffOrNeg(PlanNode planNode, DialogueAct dlgAct)
{
if (planNode is ActionNode)
{
ActionNode actNode = (ActionNode)planNode;
if (actNode.ActType == "ID" && actNode.ActState == ActionState.Executing)
{
if (actNode.Parent != null && actNode.Parent is ParamNode)
{
ParamNode paramNode = actNode.Parent as ParamNode;
if (paramNode.ParamType == "boolean")
{
return true;
}
}
}
}
return false;
}
public ActionNode(string name, string actType, string complexity, string description = "", PlanNode parent = null) : base(name, description, parent)
{
this._actType = actType;
this._complexity = complexity;
this._recipeId = -1;
this._actState = ActionState.Unknown;
this._agents = new ArrayList();
this._params = new ArrayList();
this._subActions = new ArrayList();
this._optional = false;
}
private bool _parentParamsRdy(PlanNode planNode)
{
bool paramsRdy = true; // check whether the previous params are ready
ActionNode actionNode = planNode.Parent as ActionNode;
if (actionNode != null)
{
foreach (ParamNode param in actionNode.Params)
{
if (param.Name != planNode.Name)
{
if (param.ParamState != ParamState.Ready)
{
paramsRdy = false;
}
foreach (ActionNode subAct in param.SubActions)
{
if (subAct.ActState == ActionState.Executing)
{
paramsRdy = false;
break;
}
}
if (paramsRdy == false)
{
break;
}
}
else
{
break;
}
}
}
return paramsRdy;
}
public int GetIndexInAgenda(PlanNode planNode)
{
return this._agenda.IndexOf(planNode);
}
private ActionNode _explainActionFromNode(PlanNode planNode, Hashtable tempAct, DialogueAct dlgAct, string indent)
{
Console.WriteLine(indent + "Dialogue.PlanGraph _explainActionFromNode " + planNode.Name);
ActionNode pNode = (ActionNode)planNode;
ActionNode newAction = new ActionNode((string)tempAct["name"], (string)tempAct["act_type"], (string)tempAct["complexity"], (string)tempAct["description"]);
if (planNode is ActionNode)
{
Console.WriteLine(indent + "IsActionNode actionNode:" + planNode.Name.ToLower() + " tempAct" + tempAct["name"].ToString());
// ActionNode actionNode = (ActionNode)planNode;
switch (newAction.ActType)
{
case "ACT":
{
if (pNode.Name.ToLower() == tempAct["name"].ToString().ToLower())
{
// If the action has not been initiated, initiate it and add the agent
if (pNode.ActState == ActionState.Unknown)
{
pNode.ActState = ActionState.Initiated;
}
if (pNode.SearchAgent(dlgAct.Agent) == null)
{
pNode.Agents.Add(dlgAct.Agent);
}
// If the action has been completed, or failed, start a new one, attached it to the same parent
if (pNode.ActState == ActionState.Complete || pNode.ActState == ActionState.Failed)
{
// ActionNode newAction = new ActionNode((string)tempAct["name"], (string)tempAct["act_type"], (string)tempAct["complexity"], (string)tempAct["description"], actionNode.Parent);
newAction.Parent = pNode.Parent;
newAction.Agents.Add(dlgAct.Agent);
newAction.ActState = ActionState.Initiated;
if (pNode.Parent != null)
{
if (pNode.Parent is ActionNode)
{
//There seems to be a logical error, because the newAction is now added as a subaction of pNode.Parent. This is equivalent to modifying the recipe for pNode.Parent action. The correct way to handle this should be:
// if the tempAct matches with one of the subactions that has not been initiated (potential intention), then replace that subact with newAction
ActionNode pParent = (ActionNode)(pNode.Parent);
foreach (ActionNode subact in pParent.SubActions)
{
if ((subact.Name == newAction.Name) & (subact.ActState == CAGA.Dialogue.ActionState.Unknown))
{
((ActionNode)(pNode.Parent)).SubActions.Add(newAction);
newAction.Parent = pParent;
((ActionNode)(pNode.Parent)).SubActions.Remove(subact);
}
}
}
else if (pNode.Parent is ParamNode)
{
((ParamNode)(pNode.Parent)).SubActions.Add(newAction);
}
}
return(newAction);
}
return(pNode);
}
// search the params and subactions
foreach (ParamNode paramNode in pNode.Params)
{
ActionNode actNode = this._explainActionFromNode(paramNode, tempAct, dlgAct, indent + " ");
if (actNode != null)
{
return(actNode);
}
}
foreach (ActionNode subActNode in pNode.SubActions)
{
ActionNode actNode = this._explainActionFromNode(subActNode, tempAct, dlgAct, indent + " ");
if (actNode != null)
{
return(actNode);
}
}
return(null);
}
case "REF":
// If the parent is a Action node and the new act is a reference, try to explain it as a parameter of its subaction
{
//
return(null);
}
}
return(null);
}
else if (planNode is ParamNode)
{
switch (newAction.ActType)
{
case "ACT":
{
ParamNode paramNode = (ParamNode)planNode;
foreach (ActionNode subActNode in paramNode.SubActions)
{
ActionNode actNode = this._explainActionFromNode(subActNode, tempAct, dlgAct, indent + " ");
if (actNode != null)
{
return(actNode);
}
}
return(null);
}
case "REF":
{
// explain the REF for potential match with the parameter, if the parent still expecting a parameter (paraStatus=unknown)
//retrieval the REF type, if it matches with the Parameter type, move forward
// Create a RefNode based on the newAction
// RefNode has a parant of planNode
// RefNode.execute to calculate the referenced entities and set the parameter of the planNode
RefNode newRef = new RefNode(newAction);
newRef.parent = (ParamNode)planNode;
newRef.execute();
return(null);
}
}
return(null);
}
return(null);
}
public int GetIndexInAgenda(PlanNode planNode)
{
return(this._agenda.IndexOf(planNode));
}
public void ElaborateFromNode(PlanNode planNode)
{
if (planNode is ActionNode)
{
this._elaborateFromActionNode((ActionNode)planNode);
}
else if (planNode is ParamNode)
{
this._elaborateFromParamNode((ParamNode)planNode);
}
}
/// <summary>
/// When Completed, Update Parent recursively
/// </summary>
/// <param name="planNode"></param>
/// <param name="indent"></param>
private void _updateParentState(PlanNode planNode, string indent)
{
Console.WriteLine(indent + "Dialogue.PlanGraph _updateParentState " + planNode.Name);
if (planNode.Parent != null)
{
Console.WriteLine(indent + "Parent: " + planNode.Parent.Name);
if (planNode.Parent is ActionNode)
{
ActionNode parent = (ActionNode)planNode.Parent;
foreach (ParamNode param in parent.Params)
{
if (param.ParamState != ParamState.Ready)
{
Console.WriteLine(indent + "ActionNode Parent not Completed becasue of param " + param.Name + " " + param.ParamState.ToString());
return;
}
}
foreach (ActionNode subAct in parent.SubActions)
{
if (subAct.Optional == false && subAct.ActState != ActionState.Complete)
{
Console.WriteLine(indent + "ActionNode Parent not Completed becasue of subAct " + subAct.Name + " " + subAct.ActState.ToString() + " Optional=false");
return;
}
if (subAct.Optional == true && subAct.ActState != ActionState.Complete && subAct.ActState != ActionState.Unknown)
{
Console.WriteLine(indent + "ActionNode Parent not Completed becasue of subAct " + subAct.Name + " " + subAct.ActState.ToString() + " Optional=ture");
return;
}
}
parent.ActState = ActionState.Complete;
Console.WriteLine(indent + "ActionNode Parent Completed");
this._updateParentState(parent, indent + " ");
}
else if (planNode.Parent is ParamNode)
{
ParamNode parent = (ParamNode)planNode.Parent;
if (parent.Values.Count == 0)
{
Console.WriteLine(indent + "ParamNode Parent notReady becasue of 0 value");
return;
}
else
{
foreach (object obj in parent.Values)
{
if (obj is string)
{
Console.WriteLine(indent + "******string******");
Console.WriteLine(indent + "obj=" + obj);
}
else if (obj is Hashtable)
{
Console.WriteLine(indent + "******hashtable******");
foreach (DictionaryEntry item in (Hashtable)obj)
{
Console.WriteLine(indent + "key=" + item.Key + ",value=" + item.Value);
}
}
}
}
// assume the parameter is ready as long as it has values
// it might be extended to consider the conditions on the parameter
parent.ParamState = ParamState.Ready;
this._updateParentState(parent, indent + " ");
}
}
}
private void _updateParentState(PlanNode planNode)
{
if (planNode.Parent != null)
{
if (planNode.Parent is ActionNode)
{
ActionNode parent = (ActionNode)planNode.Parent;
foreach (ParamNode param in parent.Params)
{
if (param.ParamState != ParamState.Ready)
{
return;
}
}
foreach (ActionNode subAct in parent.SubActions)
{
if (subAct.Optional == false && subAct.ActState != ActionState.Complete)
{
return;
}
if (subAct.Optional == true && subAct.ActState != ActionState.Complete && subAct.ActState != ActionState.Unknown)
{
return;
}
}
parent.ActState = ActionState.Complete;
this._updateParentState(parent);
}
else if (planNode.Parent is ParamNode)
{
ParamNode parent = (ParamNode)planNode.Parent;
if (parent.Values.Count == 0)
{
return;
}
// assume the parameter is ready as long as it has values
// it might be extended to consider the conditions on the parameter
parent.ParamState = ParamState.Ready;
this._updateParentState(parent);
}
}
}
private ArrayList _searchValueFromAncestor(PlanNode planNode, string paramName)
{
ArrayList matchedValues = new ArrayList();
if (planNode == null)
return matchedValues;
PlanNode parent = planNode.Parent;
while (parent != null)
{
if (parent is ParamNode)
{
ParamNode ancestorParam = parent as ParamNode;
if (parent.Name.ToLower() == paramName.ToLower() && ancestorParam.ParamState == ParamState.Ready)
{
matchedValues.AddRange(ancestorParam.Values);
break;
}
}
else if (parent is ActionNode)
{
ActionNode ancestorAction = parent as ActionNode;
foreach (ParamNode param in ancestorAction.Params)
{
if (param.Name.ToLower() == paramName.ToLower() && param.ParamState == ParamState.Ready)
{
matchedValues.AddRange(param.Values);
break;
}
}
}
parent = parent.Parent;
}
return matchedValues;
}
public ParamNode(string name, string paramType, bool multiple, string description = "", PlanNode parent = null) : base(name, description, parent)
{
this._paramType = paramType;
this._multiple = multiple;
this._paramState = ParamState.Unknown;
this._subActions = new ArrayList();
this._values = new ArrayList();
}
private bool _explainAnswer(PlanNode planNode, DialogueAct dlgAct)
{
if (planNode is ActionNode)
{
ActionNode actNode = (ActionNode)planNode;
if (actNode.ActType == "ID")
{
foreach (string phrase in dlgAct.SpeechContext.Keys)
{
if (phrase.ToLower() == ((ParamNode)actNode.Parent).Name.ToLower())
{
return true;
}
}
}
}
return false;
}
public PlanNode(string name, string description = "", PlanNode parent = null)
{
this._name = name;
this._description = description;
this._parent = parent;
}
public PlanNode(string name, string description="", PlanNode parent=null)
{
this._name = name;
this._description = description;
this._parent = parent;
}
