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);
}
private void _elaborateFromParamNode(ParamNode paramNode, string indent)
{
Console.WriteLine(indent + "Dialogue/PlanGraph _elaborateFromParamNode " + paramNode.Name);
bool paramsRdy = this._parentParamsRdy(paramNode, indent + " "); // check whether the previous params are ready
Console.WriteLine(indent + "paramsRdy = " + paramsRdy);
if (paramsRdy == false)
{
return;
}
if (paramNode.ParamState == ParamState.InPreparation)
{
if (paramNode.SubActions.Count > 0)
{
int idx = this.RemoveFromAgenda(paramNode, indent + " ");
foreach (ActionNode subAct in paramNode.SubActions)
{
idx = this.AddToAgenda(subAct, idx, indent + " ");
idx++;
}
foreach (ActionNode subAct in paramNode.SubActions)
{
// as soon as the parameter is ready, stop the elaboration
if (paramNode.ParamState == ParamState.Ready && subAct.Optional == true)
{
this.RemoveFromAgenda(subAct, indent + " ");
}
else
{
subAct.ActState = ActionState.Initiated;
this._elaborateFromActionNode(subAct, indent + " ");
}
}
}
}
}
private bool _parseRecipeXML(string recipeXML, ActionNode actionNode)
{
XmlDocument doc = new XmlDocument();
doc.LoadXml(recipeXML);
XmlNodeList paramList = doc.GetElementsByTagName("PARA");
foreach (XmlNode param in paramList)
{
string name = param.Attributes["Name"].Value;
string paramType = param.Attributes["Type"].Value;
bool multiple = true;
if (param.Attributes["Multiple"] != null && param.Attributes["Multiple"].Value.ToLower() == "false")
{
multiple = false;
}
string description = "";
if (param.Attributes["Description"] != null)
{
description = param.Attributes["Description"].Value;
}
ParamNode paramNode = new ParamNode(name, paramType, multiple, description, actionNode);
foreach (XmlNode node in param.ChildNodes)
{
if (node.Name == "ID_PARAS")
{
foreach (XmlNode subAct in node.ChildNodes)
{
if (subAct.Name == "ID_PARA")
{
Hashtable tempAct = this._kbase.SearchAction(subAct.Attributes["Name"].Value);
ActionNode subActNode = new ActionNode((string)tempAct["name"], (string)tempAct["act_type"], (string)tempAct["complexity"], (string)tempAct["description"], paramNode);
if (subAct.Attributes["Optional"] != null && subAct.Attributes["Optional"].Value.ToString().ToLower() == "true")
{
subActNode.Optional = true;
}
paramNode.SubActions.Add(subActNode);
}
}
}
}
actionNode.Params.Add(paramNode);
}
XmlNodeList actionList = doc.GetElementsByTagName("SUBACT");
foreach (XmlNode action in actionList)
{
Hashtable tempAct = this._kbase.SearchAction(action.Attributes["Name"].Value);
ActionNode subActNode = new ActionNode((string)tempAct["name"], (string)tempAct["act_type"], (string)tempAct["complexity"], (string)tempAct["description"], actionNode);
if (action.Attributes["Optional"] != null && action.Attributes["Optional"].Value.ToString().ToLower() == "true")
{
subActNode.Optional = true;
}
actionNode.SubActions.Add(subActNode);
}
return true;
}
private void _elaborateFromParamNode(ParamNode paramNode)
{
bool paramsRdy = this._parentParamsRdy(paramNode) ; // check whether the previous params are ready
if (paramsRdy == false)
{
return;
}
if (paramNode.ParamState == ParamState.InPreparation)
{
if (paramNode.SubActions.Count > 0)
{
int idx = this.RemoveFromAgenda(paramNode);
foreach (ActionNode subAct in paramNode.SubActions)
{
idx = this.AddToAgenda(subAct, idx);
idx++;
}
foreach (ActionNode subAct in paramNode.SubActions)
{
// as soon as the parameter is ready, stop the elaboration
if (paramNode.ParamState == ParamState.Ready && subAct.Optional == true)
{
this.RemoveFromAgenda(subAct);
}
else
{
subAct.ActState = ActionState.Initiated;
this._elaborateFromActionNode(subAct);
}
}
}
}
}
private void _addValueToParam(ParamNode paramNode, object newValue)
{
if (newValue != null)
{
if (paramNode.Multiple == false)
{
paramNode.Values.Clear();
}
else
{
foreach (object value in paramNode.Values)
{
// check whether the new value already exists
// only check string type at the moment
if (newValue is string)
{
if (newValue.ToString() == value.ToString())
{
return;
}
}
}
}
paramNode.Values.Add(newValue);
}
}
private object _parseValueFromSpeech(ParamNode paramNode, object speech)
{
if (paramNode.ParamType == "feature_class")
{
return speech.ToString();
}
else if (paramNode.ParamType == "data_source")
{
return speech.ToString();
}
else if (paramNode.ParamType == "region_type")
{
return speech.ToString();
}
else if (paramNode.ParamType == "geometry_polygon")
{
return speech.ToString();
}
else if (paramNode.ParamType == "data_field")
{
return speech.ToString();
}
else if (paramNode.ParamType == "statistics")
{
return speech.ToString();
}
else if (paramNode.ParamType == "length")
{
if (speech is SortedList)
{
Hashtable lengthInfo = new Hashtable();
if (((SortedList)speech).ContainsKey("value"))
{
lengthInfo.Add("value", ((SortedList)speech)["value"]);
}
if (((SortedList)speech).ContainsKey("unit"))
{
lengthInfo.Add("unit", ((SortedList)speech)["unit"]);
}
return lengthInfo;
}
}
else if (paramNode.ParamType == "boolean")
{
if (paramNode.Name == "partiality")
{
if (speech.ToString() == "partial")
{
return true;
}
else
{
return false;
}
}
}
return null;
}
private string _generateQuestionString(ParamNode paramNode)
{
string question = "";
if (paramNode.ParamType == "feature_class")
{
question = "What ";
if (paramNode.Description != "")
{
question += paramNode.Description;
}
else
{
question += String.Join(" ", paramNode.Name.Split('_'));
}
question += " are you working on?";
}
else if (paramNode.ParamType == "data_source")
{
question = "Which ";
if (paramNode.Description != "")
{
question += paramNode.Description;
}
else
{
question += String.Join(" ", paramNode.Name.Split('_'));
}
question += " are you working on?";
}
else if (paramNode.ParamType == "region_type")
{
question = "What is ";
if (paramNode.Description != "")
{
question += paramNode.Description;
}
else
{
question += String.Join(" ", paramNode.Name.Split('_'));
}
question += " you are interested in?";
}
else if (paramNode.ParamType == "data_field")
{
question = "Which ";
if (paramNode.Description != "")
{
question += paramNode.Description;
}
else
{
question += String.Join(" ", paramNode.Name.Split('_'));
}
question += " do you want to use?";
}
else if (paramNode.ParamType == "boolean")
{
question = "Do you ";
if (paramNode.Description != "")
{
question += paramNode.Description;
}
else
{
question += String.Join(" ", paramNode.Name.Split('_'));
}
question += "?";
}
else if (paramNode.ParamType == "length")
{
question = "What is the " + String.Join(" ", paramNode.Name.Split('_')) + "?";
}
return question;
}
/// <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 bool _parseRecipeXML(string recipeXML, ActionNode actionNode, string indent)
{
Console.WriteLine(indent + "Dialogue/PlanGraph _parseRecipeXML " + actionNode.Name);
XmlDocument doc = new XmlDocument();
doc.LoadXml(recipeXML);
XmlNodeList paramList = doc.GetElementsByTagName("PARA");
foreach (XmlNode param in paramList)
{
string name = param.Attributes["Name"].Value;
string paramType = param.Attributes["Type"].Value;
bool multiple = true;
if (param.Attributes["Multiple"] != null && param.Attributes["Multiple"].Value.ToLower() == "false")
{
multiple = false;
}
string description = "";
if (param.Attributes["Description"] != null)
{
description = param.Attributes["Description"].Value;
}
ParamNode paramNode = new ParamNode(name, paramType, multiple, description, actionNode);
bool hasParam = false;
foreach (ParamNode tmpParam in actionNode.Params)
{
//Console.WriteLine(indent + "tmpParam= " + tmpParam.Name + ",paramNode=" + paramNode.Name);
if (paramNode.Name == tmpParam.Name)
{
hasParam = true;
paramNode.Flag = true;
}
}
if (!hasParam)
{
foreach (XmlNode node in param.ChildNodes)
{
if (node.Name == "ID_PARAS")
{
foreach (XmlNode subAct in node.ChildNodes)
{
if (subAct.Name == "ID_PARA")
{
Hashtable tempAct = this._kbase.SearchAction(subAct.Attributes["Name"].Value);
Console.WriteLine("name=" + (string)tempAct["name"]);
//Console.WriteLine("act_type=" + (string)tempAct["act_type"]);
//Console.WriteLine("complexity=" + (string)tempAct["complexity"]);
//Console.WriteLine("description=" + (string)tempAct["description"]);
ActionNode subActNode = new ActionNode((string)tempAct["name"], (string)tempAct["act_type"], (string)tempAct["complexity"], (string)tempAct["description"], paramNode);
if (subAct.Attributes["Optional"] != null && subAct.Attributes["Optional"].Value.ToString().ToLower() == "true")
{
subActNode.Optional = true;
}
paramNode.Flag = true;
paramNode.SubActions.Add(subActNode);
}
}
}
}
actionNode.Params.Add(paramNode);
}
}
for (int index = actionNode.Params.Count - 1; index >= 0; index--)
{
// Get the item.
ParamNode tmpParam = (ParamNode)actionNode.Params[index];
// Check to remove.
if (tmpParam.Flag == false)
{
Console.WriteLine("what deleted is " + tmpParam.Name);
// Remove.
actionNode.Params.RemoveAt(index);
}
}
XmlNodeList actionList = doc.GetElementsByTagName("SUBACT");
foreach (XmlNode action in actionList)
{
Hashtable tempAct = this._kbase.SearchAction(action.Attributes["Name"].Value);
ActionNode subActNode = new ActionNode((string)tempAct["name"], (string)tempAct["act_type"], (string)tempAct["complexity"], (string)tempAct["description"], actionNode);
if (action.Attributes["Optional"] != null && action.Attributes["Optional"].Value.ToString().ToLower() == "true")
{
subActNode.Optional = true;
}
bool hasAction = false;
foreach (ActionNode tmpActNode in actionNode.SubActions)
{
Console.WriteLine("tmpActNode.Name=" + tmpActNode.Name + ",subActNode.Name" + subActNode.Name);
if (tmpActNode.Name == subActNode.Name)
{
hasAction = true;
}
}
if (!hasAction)
{
actionNode.SubActions.Add(subActNode);
}
}
return(true);
}
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);
}
