public StripIllegalCharacters(AltBot bot, Unifiable inputString) : base(bot, null, inputString)
{
}
public abstract override float CanUnify(Unifiable with);
protected Unifiable ProcessAsIfFileLoading()
{
{
GraphMaster g = request.Graph;
var g0 = g;
String graphName = GetAttribValue("graph", null);
if (graphName != null)
{
g = Proc.GetGraph(graphName, g0);
if (g != null)
{
request.Graph = g;
}
}
Unifiable path = GetAttribValue("filename,uri,file,url,dir,path,pathname,directory", null);
string command = GetAttribValue("command,cmd", null);
try
{
//templateNode.LocalName
string documentInfo = DocumentInfo();
request.CurrentlyLoadingFrom = documentInfo;
request.Graph = request.Graph;
string innerXML = InnerXmlText(templateNode);
if (!string.IsNullOrEmpty(command))
{
string more = "";
if (!string.IsNullOrEmpty(innerXML))
{
more = " - " + innerXML;
}
TargetBot.BotDirective(request.Requester, request,
"@" + command + " " + request.Graph.ScriptingName + more,
writeToLog);
//QueryHasSuceededN++;
}
{
try
{
if (!string.IsNullOrEmpty(innerXML) && innerXML.Contains("<"))
{
try
{
long successes = request.Loader.loadAIMLNode(templateNode);
return("" + successes);
}
finally
{
}
}
else if (path == "")
{
writeToLogWarn(
"ERROR! Attempted (but failed) to <learn> some new AIML from the following URI: '{0}' - '{1}'",
path, innerXML);
}
else
{
path = path ?? innerXML;
request.CurrentFilename = path;
long forms = request.Loader.loadAIMLURI(path);
QueryHasSuceededN++;
return("" + forms); // Succeed();
}
}
catch (ChatSignal e)
{
throw;
}
catch (Exception e2)
{
Proc.writeToLog(e2);
writeToLogWarn(
"ERROR! Attempted (but failed) to <learn> some new AIML from the following URI: {0} error {1}",
path, e2);
}
}
return(Succeed("learned something"));
}
finally
{
request.Graph = g0;
}
}
}
public ApplySubstitutions(AltBot bot, Unifiable inputString)
: base(bot, null, inputString)
{
}
protected override Unifiable ProcessChangeU()
{
Unifiable defaultVal = GetAttribValue("default,defaultValue", null);
if (CheckNode("set"))
{
var templateNodeInnerText = Recurse();
Unifiable name = GetAttribValue("name,var", null);
Unifiable value = GetAttribValue("value", null);
string gName = GetAttribValue("global_name", null);
ISettingsDictionary dict;
string dictName = GetNameOfDict(query, "set", templateNode, out dict);
Succeed();
if (name == null)
{
//recursive form like <set>name value Unifiable</set>
name = templateNodeInnerText.First;
var strV = templateNodeInnerText.Rest;
if (!IsNull(strV))
{
if (IsNull(value))
{
value = strV;
}
else
{
writeToLogWarn("ERROR extra stuff in ", strV);
}
}
}
else
{
if (value == null)
{
var strV = templateNodeInnerText;
if (IsNull(strV))
{
writeToLogWarn("ERROR null stuff in SET ", strV);
}
value = strV;
}
}
string setReturn = GetAttribValue <string>(templateNode, "set-return",
() => ((string)Proc.GetRelationMetaProps().GetMeta(name, "set-return")),
ReduceStarAttribute <string>);
if (value == null)
{
value = templateNodeInnerText;
}
if (IsNull(value))
{
value = defaultVal;
}
if (IsNull(value))
{
if (QueryHasFailed)
{
return(FAIL);
}
}
var retVal = NamedValuesFromSettings.SetSettingForType(dictName, query, dict, name, gName, value, setReturn, templateNode);
if (IsNull(retVal))
{
writeToLogWarn("ERROR null stuff in SET ", retVal);
}
else if (IsIncomplete(retVal))
{
writeToLogWarn("ERROR null stuff in SET ", retVal);
}
return(retVal);
}
return(defaultVal);
}
public void SetValue(object oldValue, object newValue, object unused)
{
setter.Invoke((T)(object)Unifiable.Create(newValue));
}
public MakeCaseInsensitive(AltBot bot, Unifiable inputString)
: base(bot, null, inputString)
{
}
/// <summary>
/// The method that does the actual Processing of the text.
/// </summary>
/// <returns>The resulting Processed text</returns>
protected override Unifiable ProcessChangeU()
{
if (templateNode.NodeType == XmlNodeType.Comment)
{
return(Succeed(templateNode.Value));
}
if (templateNode.NodeType == XmlNodeType.Text)
{
string s = Trim(templateNode.InnerText);
if (String.IsNullOrEmpty(s))
{
return(Unifiable.Empty);
}
return(s);
}
string currentNodeName = templateNode.Name.ToLower();
if (currentNodeName == "substitutions")
{
var prevDict = request.TargetSettings;
// Process each of these child "settings"? nodes
try
{
request.TargetSettings = request.TargetBot.InputSubstitutions;
SettingsDictionaryReal.loadSettingNode(request.TargetSettings, templateNode, SettingsPolicy.Default, request);
}
finally
{
request.TargetSettings = prevDict;
}
return(ProcessSucceed());
}
if (currentNodeName == "genlmt")
{
string name = GetAttribValue(templateNode, "name,mt,to,super,into", null);
string removeTo = GetAttribValue(templateNode, "remove", null);
string from = GetAttribValue(templateNode, "graph,from", null);
bool deleteLink = false;
if (name == null)
{
name = Trim(templateNode.InnerText);
}
if (removeTo != null)
{
deleteLink = true;
name = removeTo;
}
GraphMaster FROM = request.GetGraph(from);
GraphMaster TO = request.GetGraph(name);
if (FROM != null && TO != null)
{
if (deleteLink)
{
FROM.RemoveGenlMT(TO, writeToLog);
}
else
{
FROM.AddGenlMT(TO, writeToLog);
}
return(Succeed("GENLMT: " + FROM + " => " + name + " => " + TO));
}
}
if (currentNodeName == "sraigraph")
{
string name = GetAttribValue(templateNode, "name,mt,to,super,into", null);
string from = GetAttribValue(templateNode, "graph,from", null);
if (name == null)
{
name = Trim(templateNode.InnerText);
}
GraphMaster FROM = request.GetGraph(from);
GraphMaster TO = request.GetGraph(name);
if (FROM != null && TO != null)
{
FROM.Srai = name;
return(Succeed("SRAI: " + FROM + " => " + name + " => right now " + TO));
}
return(Failure("FROM '" + from + "'='" + FROM + "'" + " TO '" + name + "'='" + TO + "'"));
}
if (currentNodeName == "meta")
{
return(Succeed("UNUSED: " + templateNode.OuterXml));
}
if (currentNodeName == "#comment")
{
return(Succeed("UNUSED: " + templateNode.OuterXml));
}
if (currentNodeName == "item")
{
SettingsDictionaryReal.loadSettingNode(request.TargetSettings, templateNode, SettingsPolicy.Default, request);
return(ProcessSucceed());
}
if (currentNodeName == "bot")
{
SettingsDictionaryReal.loadSettingNode(request.TargetBot.Settings, templateNode, SettingsPolicy.Default, request);
return(ProcessSucceed());
}
string currentNodeOuterXml = templateNode.OuterXml;
if (currentNodeOuterXml.Length > 280)
{
currentNodeOuterXml = TextFilter.ClipString(currentNodeOuterXml, 280);
}
writeToLog("ImmediateAiml: " + currentNodeOuterXml);
/*
* <TestCase name="connect">
* <Input>CONNECT</Input>
* <ExpectedAnswer>Connected to test case AIML set.</ExpectedAnswer>
* </TestCase>
*/
if (templateNode.NodeType == XmlNodeType.Comment)
{
return(ProcessSucceed());
}
// pull from late bound sustituion dictionaries
var sd = request.GetSubstitutions(currentNodeName, false);
if (sd != null)
{
if (FinalResultValid)
{
return(FinalResult);
}
if (!Unifiable.IsIncomplete(FinalResult))
{
return(FinalResult);
}
Func <Unifiable, Unifiable> Format = (v) => ApplySubstitutions.Substitute(sd, templateNodeInnerText);
if (base.isRecursive && !ReadOnly)
{
FinalResult = Format(TransformAtomically(null, true));
return(finalResult.Value);
}
return(FinalResult = TransformAtomically(Format, false));
}
if (AltBot.UnknownTagsAreBotVars)
{
var dict = Proc.GlobalSettings;
if (dict.containsSettingCalled(currentNodeName))
{
var v = dict.grabSetting(currentNodeName);
if (!Unifiable.IsMissing(v))
{
return(v);
}
}
}
var vs = Proc.EvalAiml(templateNode, request, request.writeToLog);
StringBuilder sb = new StringBuilder();
int writeThrus = 0;
int total = 0;
OutputDelegate WriteLine = DLRConsole.SystemWriteLine;
foreach (var node in vs)
{
total++;
string nodeOuterXml = ToXmlValue(node);
WriteLine(nodeOuterXml);
string p = GetAttribValue(node, "PASSED", "FALSE");
if (p == "False")
{
writeThrus++;
sb.Append("\n" + nodeOuterXml.Replace("\" ", "\"\n ") + "\n");
}
WriteLine("");
}
WriteLine("");
WriteLine("");
WriteLine("" + writeThrus);
WriteLine("");
string ss = sb.ToString();
WriteLine(ss);
WriteLine("");
WriteLine("");
WriteLine("");
return(Succeed("total is " + total));
}
public string ExpandFormat(string subj, string relation, object value, bool isQuery, SettingsDictionary dictionary, Unifiable formatter, XmlNode templateNode)
{
string pred = Entify(relation);
string botName = !IsBotRobot(subj) ? Entify(TheBot.BotUserID) : Entify(TheBot.LastUser.UserID);
{
var whword = GetDictValue(dictionary, relation, "format-whword");
if (!Unifiable.IsNullOrEmpty(whword) && isQuery)
{
value = whword;
}
var formatterUpper = Unifiable.ToUpper(formatter);
if (Unifiable.IsFalseOrNo(formatterUpper))
{
return("false");
}
formatter = ReplaceWord(formatter, "$subject", "{0}");
formatter = ReplaceWord(formatter, "$verb", "{1}");
formatter = ReplaceWord(formatter, "$object", "{2}");
formatter = ReplaceWord(formatter, "$user", "{0}");
formatter = ReplaceWord(formatter, "$relation", "{1}");
formatter = ReplaceWord(formatter, "$value", "{2}");
formatter = ReplaceWord(formatter, "$predicate", pred);
formatter = ReplaceWord(formatter, "$set-return",
TheBot.RelationMetaProps.grabSetting(relation + "." + "set-return"));
formatter = ReplaceWord(formatter, "$default", TheBot.DefaultPredicates.grabSetting(relation));
formatter = ReplaceWord(formatter, "$botname", botName);
formatter = ReplaceWord(formatter, "$bot", botName);
}
string english = " " + String.Format(formatter, subj, pred, Entify(value)).Trim() + " ";
english = ReplaceWord(english, "I", subj);
english = ReplaceWord(english, "you", botName);
english = english.Trim();
User user = TheBot.FindUser(subj);
english = FixPronouns(english, user.grabSettingNoDebug);
return(english);
}
/// <summary>
/// Checks to see if a setting of a particular name exists
/// </summary>
/// <param name="name">The setting name to check</param>
/// <returns>Existential truth value</returns>
public bool containsSettingCalled(string name)
{
Unifiable value = grabSetting(name);
return(!Unifiable.IsNullOrEmpty(value));
}
public Utterance(Func <Unifiable, Unifiable> generatePhrase, User speaker, User toWhom, Unifiable rawText, int maxSentences)
{
Speaker = speaker;
ToWhom = toWhom;
OrignalRawText = rawText;
OutputSentencesToEnglish = generatePhrase;
if (maxSentences < 10)
{
maxSentences = 10;
}
maxResults = maxSentences + 10;
}
public override float CanUnify(Unifiable with)
{
writeToLogWarn("CANUNIFY: " + with);
return(base.CanUnify(with));
}
static Unifiable IfSucceed(XmlNode templateNode, ISettingsDictionary dict, SubQuery query0, Func <Unifiable> Succeed, Func <string, Unifiable> Failure)
{
lock (templateNode)
{
// ISettingsDictionary dict = query;
//if (GetAttribValue(templateNode, "type", "") == "bot" || GetAttribValue(templateNode,"bot", "").ToLower() == "true")
// dict = query0.TargetBot.GlobalSettings;
bool yesInherit = true;
bool noLocal = false;
string locally = GetAttribValue(templateNode, "scope,type,exists", "");
if (locally.Contains("local"))
{
yesInherit = false;
}
if (locally.Contains("inher"))
{
noLocal = true;
yesInherit = true;
}
Func <IConvertible, string> query = query0.ReduceStarAttribute <string>;
string name = GetAttribValue <string>(templateNode, "name,var,if", NullStringFunct, query);
string expression = GetAttribValue <string>(templateNode, "expr", NullStringFunct, query);
string exists = GetAttribValue(templateNode, "exists", NullStringFunct, query);
string contains = GetAttribValue(templateNode, "contains", NullStringFunct, query);
Unifiable value = GetAttribValue(templateNode, "value", NullStringFunct, query);
string scope = GetAttribValue(templateNode, "local,scope", NullStringFunct, query);
string realName0;
string type = GetAttribValue(templateNode, "type,user,bot", out realName0, NullStringFunct, query);
if (type == null)
{
type = realName0;
}
string varname = name ?? exists;
bool mustNotExist = false;
if (contains != null)
{
value = ".*" + contains + ".*";
}
if (exists != null)
{
bool locallyContains = dict.containsLocalCalled(name);
bool anyContains = dict.containsSettingCalled(name);
if (exists.StartsWith("local"))
{
if (!locallyContains)
{
return(Unifiable.Empty);
}
return(Succeed());
}
exists = exists.ToLower();
if (exists == "inherited")
{
if (!locallyContains && anyContains)
{
return(Succeed());
}
return(Failure("" + name + "=" + anyContains + " !inherited "));
}
if (exists == "false")
{
if (!yesInherit)
{
if (!locallyContains)
{
return(Succeed());
}
}
if (noLocal)
{
if (anyContains && !locallyContains)
{
return(Succeed());
}
}
return(Failure("" + name + "=" + anyContains + " !false "));
}
if (exists == "true")
{
if (!yesInherit)
{
if (locallyContains)
{
return(Succeed());
}
}
if (noLocal)
{
if (!locallyContains && anyContains)
{
return(Succeed());
}
}
return(Failure("" + name + "=" + anyContains + " " + templateNode.OuterXml));
}
string realName;
bool succeed;
//ReduceStar0 query = query0.ReduceStarAttribute;
Unifiable actualValue = GetActualValue(templateNode, name, type ?? dict.NameSpace, out succeed, query0);
if (IsPredMatch(value, actualValue, query0))
{
return(Succeed());
}
else
{
return(Failure("" + name + "=" + anyContains + " " + templateNode.OuterXml));
}
}
return(Succeed());
}
}
public virtual float DefaultCanUnify(Unifiable with)
{
return(ComputeInnerOrNull().Unify(with, this.query));
}
/// <summary>
/// An ease-of-use static method that re-produces the instance transformation methods
/// </summary>
/// <param name="input">The Unifiable to transform</param>
/// <returns>The resulting Unifiable</returns>
public static Unifiable TransformInput(Unifiable input)
{
return(input.ToCaseInsensitive());
}
protected void SetWith(XmlNode childNode, Unifiable with)
{
MEMBER = new Unifiable[] { with };
}
public static Action EnterTag(Request request, XmlNode templateNode, SubQuery query)
{
if (templateNode.NodeType != XmlNodeType.Element)
{
return(DoNothing);
throw new NotImplementedException("EnterTag: " + templateNode.NodeType);
}
bool needsUnwind = false;
UndoStackHolder thiz = (UndoStackHolder)query ?? request;
ISettingsDictionary dict = query;
if (dict == null && request != null)
{
dict = request.TargetSettings;
}
XmlAttributeCollection collection = templateNode.Attributes;
EnterContext(request, query);
if (collection == null || collection.Count <= 0)
{
return(() =>
{
ExitContext(request, query);
});
}
else
{
var used = new List <XmlAttribute>();
string defaultElement = "";
Action gmrerstore;
gmrerstore = request.WithAttributesForUnwind(templateNode, ref defaultElement, used);
int uc = used.Count;
UndoStack savedValues = null;
foreach (XmlAttribute node in collection)
{
if (used.Contains(node))
{
continue;
}
bool found;
string n = node.Name.ToLower();
switch (n)
{
case "state":
case "flag":
case "graph":
case "topic":
case "that":
break;
default:
{
lock (ReservedAttributes)
{
if (ReservedAttributes.Contains(n))
{
continue;
}
bool prev = NamedValuesFromSettings.UseLuceneForGet;
try
{
NamedValuesFromSettings.UseLuceneForGet = false;
if (!dict.containsSettingCalled(n))
{
ReservedAttributes.Add(n);
request.writeToLog("ReservedAttributes: {0}", n);
}
else
{
if (!PushableAttributes.Contains(n))
{
PushableAttributes.Add(n);
request.writeToLog("PushableAttributes: {0}", n);
}
}
}
finally
{
NamedValuesFromSettings.UseLuceneForGet = prev;
}
}
// now require temp vars to s ay with_id="tempId"
// to set the id="tempid" teporarily while evalig tags
if (!n.StartsWith("with_"))
{
continue;
}
else
{
n = n.Substring(5);
}
Unifiable v = ReduceStar <Unifiable>(node.Value, query, dict, out found);
UndoStack.FindUndoAll(thiz, true);
savedValues = savedValues ?? UndoStack.GetStackFor(thiz);
//savedValues = savedValues ?? query.GetFreshUndoStack();
savedValues.pushValues(dict, n, v);
needsUnwind = true;
}
break;
}
}
// unwind
return(() =>
{
if (needsUnwind)
{
try
{
EnterContext(request, query);
if (savedValues != null)
{
savedValues.UndoAll();
}
}
catch (Exception ex)
{
request.writeToLog("ERROR " + ex);
}
finally
{
ExitContext(request, query);
}
}
ExitContext(request, query);
if (uc > 0)
{
gmrerstore();
}
});
}
}
public override float CanUnify(Unifiable with)
{
throw new NotImplementedException();
}
public static bool ContainsAiml(Unifiable unifiable)
{
String s = unifiable.AsString();
return(StaticXMLUtils.ContainsXml(s));
}
private XmlNode RunTest(Request request, XmlNode src, OutputDelegate outputdelegate, out bool m)
{
// request = request ?? Loader.LoaderRequest00;
User user = request.Requester;
AltBot robot = request.TargetBot ?? Loader.TargetBot;
string tcname = StaticXMLUtils.FindNodeOrAttrib(src, "name", null);
string tcdesc = FindNodeOrAttrib(src, "Description", null);
string input = FindNodeOrAttrib(src, "Input", null);
if (input == null)
{
outputdelegate("ERROR cannot find 'Input' in '" + src.OuterXml + "'");
m = false;
return(getNodeAndSetSibling(false,
"<template type=\"error\">ERROR cannot find 'Input' in '" + src.OuterXml + "'</template>", true,
false, src));
}
string userID = FindNodeOrAttrib(src, "UserId,UserName", () => user.UserID);
const string MISSING_EXPECTED_ANSWER = "ExpectedKeywords";
var matchTheseToPass = new List <string>();
string expectedAnswer = FindNodeOrAttrib(src, "ExpectedAnswer", () => MISSING_EXPECTED_ANSWER);
expectedAnswer = Fudge(expectedAnswer);
if (expectedAnswer == MISSING_EXPECTED_ANSWER)
{
var nodes = FindNodes("ExpectedKeywords", src);
if (nodes == null || nodes.Count == 0)
{
outputdelegate("ERROR cannot find 'ExpectedAnswer' in '" + src.OuterXml + "'");
}
else
{
foreach (XmlNode list in nodes)
{
string v = Unifiable.InnerXmlText(list);
matchTheseToPass.Add(".*" + Fudge(v) + ".*");
}
}
}
else
{
matchTheseToPass.Add("^" + Fudge(expectedAnswer) + "$");
}
outputdelegate("{0}: {1} ", tcname, tcdesc);
outputdelegate("{0}: {1} ", userID, input);
string resp = "ERROR";
try
{
var requestToBot = robot.MakeRequestToBot(input, userID, true, RequestKind.ChatRealTime);
requestToBot.IsTraced = traceIt;
if (traceIt)
{
AltBot.Breakpoint("testing...");
requestToBot.DebugLevel = 9;
}
Result result = robot.Chat(requestToBot);
resp = result.Output ?? result.ToString() ?? resp;
if (resp == null)
{
resp = "NULLED";
}
resp = Fudge(resp);
outputdelegate("{0}: {1} ", robot, resp);
m = true;
int good = 0;
foreach (string s in matchTheseToPass)
{
if (!Matches(resp, s, FindNodeOrAttrib(src, "MatchType,Match", null)))
{
m = false;
}
else
{
good++;
}
}
outputdelegate("PASSED={0}", m);
if (traceIt)
{
AltBot.Breakpoint("tested...");
}
return(GetMessage(src, "PASSED='" + m +
"'", "TESTCASE='" + tcname + "' GOOD='" + good +
"' RESPNS='" + resp +
"' EXPECT='" + expectedAnswer +
"' INPUT='" + input +
"' DESC='" + tcdesc + "'"));
}
catch (Exception err)
{
string ERRMSG = "" + err;
m = false;
errorCount++;
return(GetMessage(src, "PASSED='" + m +
"'", "TESTCASE='" + tcname + "' ERRMSG='" + ERRMSG + "' RESP='" + resp +
"' EXPECT='" + expectedAnswer +
"' INPUT='" + input +
"' DESC='" + tcdesc + "'"));
}
}
public static Unifiable AltStar(string name, SubQuery query, ISettingsDictionary dict, out bool rfound)
{
try
{
if (name.Contains(","))
{
foreach (string subname in NamesStrings(name))
{
var val = AltStar(name, query, dict, out rfound);
if (rfound)
{
rfound = true;
return(val);
}
}
}
if (name.StartsWith("star_"))
{
return(GetDictData(query.InputStars, name, 5, out rfound));
}
else if (name.StartsWith("inputstar_"))
{
return(GetDictData(query.InputStars, name, 10, out rfound));
}
else if (name.StartsWith("input_"))
{
return(GetDictData(query.InputStars, name, 6, out rfound));
}
else if (name.StartsWith("thatstar_"))
{
return(GetDictData(query.ThatStars, name, 9, out rfound));
}
else if (name.StartsWith("that_"))
{
return(GetDictData(query.ThatStars, name, 5, out rfound));
}
else if (name.StartsWith("topicstar_"))
{
return(GetDictData(query.TopicStar, name, 10, out rfound));
}
else if (name.StartsWith("topic_"))
{
return(GetDictData(query.TopicStar, name, 6, out rfound));
}
else if (name.StartsWith("guardstar_"))
{
return(GetDictData(query.GuardStar, name, 10, out rfound));
}
else if (name.StartsWith("guard_"))
{
return(GetDictData(query.GuardStar, name, 6, out rfound));
}
else if (name.StartsWith("@"))
{
Unifiable value = query.Request.TargetBot.SystemExecute(name, null, query.Request);
rfound = true;
if (!IsNullOrEmpty(value))
{
return(value);
}
return(value);
}
else if (name.StartsWith("%dictvar_"))
{
Unifiable value = value = GetValue(query, dict, name.Substring(8), out rfound);
if (rfound)
{
return(value);
}
return(value);
}
else
{
if (name.StartsWith("%") || name.StartsWith("$"))
{
string str = name.Substring(1);
var vv = ResolveVariableValue(str, query, dict, out rfound);
if (rfound)
{
return(vv);
}
return(vv);
}
else if (name.Contains("."))
{
var vv = ResolveVariableValue(name, query, dict, out rfound);
if (rfound)
{
return(vv);
}
return(vv);
}
rfound = false;
return(name);
}
}
catch (Exception e)
{
AltBot.writeDebugLine("" + e);
rfound = false;
return(null);
}
}
protected Unifiable ProcessChangeMSM()
{
//if (this.templateNode.Name.ToLower() == "Processmsm")
{
string machine = GetAttribValue("name", null);
string line = templateNodeInnerText.ToValue(query);
AltBot.writeDebugLine("\n\n >>>>>>>>>>>>>>>>>>>>>> PROCESSMSM : |{0}|<<<<<<<<<<<<<<<<<<<<", line);
//varMSM.lastDefMachine = machine;
var varMSM = botActionMSM;
varMSM.addMachine(machine);
// set topic to "collectevidencepatterns"
//Proc.AddAiml("<set name='topic'>collectevidencepatters</set>");
//this.user.Predicates.updateSetting("topic", "collectevidencepatters");
user.TopicSetting = "CEP";
// Clear the evidence and next state
varMSM.clearEvidence();
varMSM.clearNextStateValues();
// estimate what evidence can be gleaned from the current state
varMSM.inspectEvidenceStates();
// Process the input text
//string evidenceReply = Proc.ChatString(line, this.user.UserID);
string evidenceReply = subChat(line, user.TopicSetting, request, true);
AltBot.writeDebugLine("MSM: WithEvidence {0} ", varMSM.ToString());
// TODO: we should also get evidence across machine boundries
// compute the "TRUE" topics from the state machines,advance all machines using evidence
Hashtable machinesTopState = new Hashtable();
foreach (string mac in varMSM.machines.Keys)
{
string top_State = varMSM.advanceMachine(mac);
machinesTopState[mac] = top_State;
}
// make the next_state values the new current state values
varMSM.advanceStateValues();
AltBot.writeDebugLine("MSM: AfterAdvance {0} ", varMSM.ToString());
// For each machine set the appropriate topic, and Process the input text
string totalReply = "";
double strongestVal = -9999;
foreach (string actingMachine in machinesTopState.Keys)
{
string actionState = (string)machinesTopState[actingMachine];
double actp = (double)varMSM.cur_machineStateVal[actionState];
Hashtable topicHt = (Hashtable)varMSM.machineStateResponses[actionState];
if ((topicHt != null) && (topicHt.Count > 0))
{
foreach (string responseTopic in topicHt.Keys)
{
//prob = topicHt[responseTopic] = prob;
string responseTopicUp = ToUpper(responseTopic);
//string topicSet = "<set name='topic'>"+responseTopic+"</set>";
//this.user.Predicates.updateSetting("topic", responseTopic);
user.TopicSetting = responseTopicUp;
//Proc.AddAiml(topicSet);
string actionReply = "";
//actionReply = Proc.ChatString(line, this.user.UserID);
actionReply = subChat(line, responseTopicUp, request, false);
// Append or use non-null response with the most certainty
//totalReply += " " + actionReply;
AltBot.writeDebugLine("MSM:[[ PossReply m:{0} s:{1} p:{2} RT: {3} REPLY:{4} ]] <<< * * * * * *", actingMachine, actionState, actp, responseTopicUp, actionReply.Trim());
if ((actp > strongestVal) && (actionReply.Trim().Length > 0))
{
strongestVal = actp;
totalReply = actionReply;
}
}
}
}
Unifiable result = totalReply.Trim();
AltBot.writeDebugLine("MSM: FinalReply :{0}", totalReply.Trim());
return(result);
}
return(Unifiable.Empty);
}
protected virtual Unifiable Format(Unifiable unifiable)
{
return(unifiable);
}
public static CategoryInfo GetCategoryInfo(Unifiable info, XmlNode node, LoaderOptions filename, XmlNode templateNode,
Unifiable template, Unifiable guard, Unifiable topicInfo, Node patternNode, Unifiable thatInfo, IEnumerable <ConversationCondition> conds)
{
return(filename.Graph.FindCategoryInfo(info, node, filename, templateNode, template, guard, topicInfo,
patternNode, thatInfo, conds));
}
public AIMLTagHandlerB(AltBot bot, string instr, Unifiable inu)
{
this.bot = bot;
inputStringU = inu ?? instr;
inputString = initialString = instr ?? inputStringU.AsString();
}
