internal BehaviorContext(AltBot mbot, User user)
{
base.bot = mbot;
ReadOnly = true;
_user = user;
if (_user != null)
{
_user.BehaviorContext = this;
}
}
/// <summary>
/// Loads any custom tag handlers found in the dll referenced in the argument
/// </summary>
/// <param name="pathToDLL">the path to the dll containing the custom tag handling code</param>
static public void loadCustomTagHandlers(string pathToDLL)
{
// return;
string hostSystemResolveToExistingPath = HostSystem.ResolveToExistingPath(pathToDLL);
if (hostSystemResolveToExistingPath == null)
{
throw new FileNotFoundException(pathToDLL);
}
Assembly tagDLL = Assembly.LoadFrom(hostSystemResolveToExistingPath);
var tagDLLTypes = tagDLL.GetTypes();
for (int i = 0; i < tagDLLTypes.Length; i++)
{
Type type = tagDLLTypes[i];
try
{
var typeCustomAttributes = type.GetCustomAttributes(false);
if (typeCustomAttributes.Length == 0 && typeof(AIMLTagHandler).IsAssignableFrom(type) &&
!type.IsAbstract && !type.IsInterface)
{
try
{
AddTagHandler(type);
}
catch (Exception e)
{
AltBot.writeException(e);
}
continue;
}
for (int j = 0; j < typeCustomAttributes.Length; j++)
{
if (typeCustomAttributes[j] is CustomTagAttribute)
{
// We've found a custom tag handling class
// so store the assembly and store it away in the Dictionary<,> as a TagHandler class for
// later usage
try
{
AddTagHandler(type);
}
catch (Exception e)
{
AltBot.writeException(e);
}
}
}
}
catch (Exception ee)
{
AltBot.writeException(ee);
}
}
}
public void processTransition(XmlNode transitionNode, AltBot bot0)
{
BehaviorContext bot = bot0.BotBehaving;
Console.WriteLine("FSM: processTransition {0}", transitionNode.InnerText);
foreach (XmlNode templateNode in transitionNode.ChildNodes)
{
bot.evalTemplateNode(templateNode, RequestKind.StateMachineProcess);
}
}
public void AddMore(string m)
{
if (Noise(m))
{
return;
}
if (m.ToLower().StartsWith(message.ToLower()))
{
message = AltBot.ReTrimAndspace(m);
return;
}
message += " " + m;
message = AltBot.ReTrimAndspace(message);
}
public void runBotMachines(AltBot bot)
{
foreach (string machineName in machines.Keys)
{
try
{
Qfsm curMachine = (Qfsm)machines[machineName];
curMachine.advanceBotMachine(bot);
}
catch (Exception e)
{
Console.WriteLine("ERR:" + e.Message);
Console.WriteLine("ERR:" + e.StackTrace);
}
}
}
private bool Noise(string s)
{
s = AltBot.ReTrimAndspace(s.ToLower());
if (s == "um,")
{
return(true);
}
if (s == "you know,")
{
return(true);
}
if (message.ToLower().EndsWith(s))
{
return(true);
}
return(false);
}
internal AIMLTagHandler GetTagHandler(User user, SubQuery query, Request request, Result result, XmlNode node,
AIMLTagHandler parentTagHandlerU)
{
AltBot targetBot = user.bot;
AIMLTagHandler tag = targetBot.GetTagHandler(node, query, request, result, user, true);
if (query != null)
{
query.CurrentTagHandlerU = tag;
}
if (query != null)
{
query.CurrentNode = node;
}
if (tag == null)
{
writeToLog("NULL TAG " + node.OuterXml);
}
if (tag != null)
{
tag.SetParent(parentTagHandlerU);
if (query != null)
{
query.LastTagHandlerU = parentTagHandlerU ?? tag;
}
TemplateInfo ti = tag.templateInfo;
if (ti == null && query != null)
{
ti = query.CurrentTemplate;
}
if (ti == null && parentTagHandlerU != null)
{
ti = parentTagHandlerU.GetTemplateInfo();
}
if (ti != null)
{
tag.templateInfo = ti;
}
else
{
// writeToLog("DEBUG9 Missing templateInfo " + node.OuterXml);
}
}
return(tag);
}
/// <summary>
/// Recursively evaluates the template nodes returned from the Proccessor
/// </summary>
/// <param name="node">the node to evaluate</param>
/// <param name="query">the query that produced targetBot node</param>
/// <param name="request">the request from the user</param>
/// <param name="result">the result to be sent to the user</param>
/// <param name="user">the user who originated the request</param>
/// <returns>the output Unifiable</returns>
public string processNodeVV(XmlNode node, SubQuery query,
Request request, Result result, User user,
AIMLTagHandler parentHandlerU, bool protectChild, bool copyParent,
AIMLTagHandler tagHandlerU, out bool childSuccess)
{
AltBot TargetBot = tagHandlerU.bot;
if (request != null)
{
TargetBot = request.TargetBot;
}
childSuccess = true;
if (node == null)
{
string whyError = "ERROR null NODE " + tagHandlerU;
writeToLog(whyError);
throw new ChatSignalOverBudget(request, whyError);
}
if (node.NodeType == XmlNodeType.Text)
{
childSuccess = true;
if (tagHandlerU != null)
{
tagHandlerU.QueryHasSuceeded = true;
}
string s = StaticAIMLUtils.Trim(StaticAIMLUtils.TextNodeValue(node));
if (!String.IsNullOrEmpty(s))
{
return(StaticAIMLUtils.ValueText(s));
}
//return s;
}
if (tagHandlerU == null)
{
string whyError = "ERROR null THND " + node;
childSuccess = false;
writeToLog(whyError);
}
bool isTraced = (request != null && (request.IsTraced || !request.GraphsAcceptingUserInput)) ||
(query != null && query.IsTraced);
// check for timeout (to avoid infinite loops)
bool overBudget = false;
if (request != null && request.IsComplete(result))
{
object gn = request.Graph;
if (query != null)
{
gn = query.Graph;
}
string s = StaticAIMLUtils.SafeFormat("WARNING! Request " + request.WhyComplete +
". User: {0} raw input: {3} \"{1}\" processing {2} templates: \"{4}\"",
request.Requester.UserID, Unifiable.DescribeUnifiable(request.rawInput),
(query == null ? "-NOQUERY-" : query.Templates.Count.ToString()), gn, node);
if (isTraced)
{
request.writeToLog(s);
}
overBudget = true;
if (!request.IsToplevelRequest)
{
throw new ChatSignalOverBudget(request, s);
}
}
// process the node
if (ReferenceEquals(null, tagHandlerU))
{
childSuccess = true;
if (node.NodeType == XmlNodeType.Comment)
{
return(Unifiable.Empty);
}
if (node.NodeType == XmlNodeType.Text)
{
string s = StaticAIMLUtils.Trim(StaticAIMLUtils.TextNodeValue(node));
if (String.IsNullOrEmpty(s))
{
return(Unifiable.Empty);
}
return(s);
}
// ReSharper disable ConditionIsAlwaysTrueOrFalse
OutputDelegate del = (request != null) ? request.writeToLog : writeToLog;
// ReSharper restore ConditionIsAlwaysTrueOrFalse
if (overBudget)
{
return(Unifiable.Empty);
}
string nodeInner = node.InnerXml;
TargetBot.EvalAiml(node, request, del ?? TextPatternUtils.DEVNULL);
return(node.InnerXml);
}
XmlNode oldNode = node;
bool wasReadonlyNode = oldNode.IsReadOnly;
// copy the node!?!
if (protectChild)
{
copyParent = true;
LineInfoElementImpl newnode = StaticAIMLUtils.CopyNode(node, copyParent);
newnode.ReadOnly = false;
node = newnode;
}
if (overBudget)
{
tagHandlerU.Dispose();
tagHandlerU = null;
childSuccess = true;
return(Unifiable.Empty);
}
tagHandlerU.SetParent(parentHandlerU);
//if (parent!=null) parent.AddChild(tagHandler);
Unifiable cp = tagHandlerU.Transform();
if (Unifiable.IsNullOrEmpty(cp) && (!tagHandlerU.QueryHasSuceeded || tagHandlerU.QueryHasFailed))
{
bool needsOneMoreTry = !request.SuspendSearchLimits &&
(request.IsToplevelRequest /*|| result.ParentRequest.IsToplevelRequest*/);
if (isTraced || needsOneMoreTry)
{
//writeDebugLine("ERROR: Try Again since NULL " + tagHandler);
bool wsl = request.SuspendSearchLimits;
try
{
request.SuspendSearchLimits = true;
cp = tagHandlerU.Transform();
if (Unifiable.IsNull(cp))
{
childSuccess = false;
return(tagHandlerU.GetTemplateNodeInnerText());
}
if (false && Unifiable.IsNullOrEmpty(cp))
{
// trace the next line to see why
AIMLTagHandler handlerU = tagHandlerU;
TargetBot.TraceTest("ERROR: Try Again since NULL " + handlerU,
() => { cp = handlerU.Transform(); });
}
}
finally
{
request.SuspendSearchLimits = wsl;
}
}
}
if (tagHandlerU.QueryHasFailed)
{
childSuccess = false;
return(tagHandlerU.FAIL);
}
childSuccess = !tagHandlerU.QueryHasFailed;
if (!childSuccess)
{
}
var st = StaticAIMLUtils.IsSilentTag(node);
var ine = Unifiable.IsNullOrEmpty(cp);
if (!ine || st)
{
childSuccess = true;
return(cp);
}
if (Unifiable.IsNull(cp))
{
cp = tagHandlerU.GetTemplateNodeInnerText();
if (tagHandlerU.QueryHasSuceeded)
{
childSuccess = true;
return(cp);
}
return(cp);
}
return(cp);
}
internal AIMLTagHandler GetTagHandlerU(User user, SubQuery query, Request request, Result result, XmlNode node, bool liText)
{
AIMLTagHandler tagHandlerU = getBespokeTags(user, query, request, result, node);
string nodeNameLower = StaticAIMLUtils.ToLower(node.LocalName);
AltBot targetBot = query.TargetBot;
if (Equals(null, tagHandlerU))
{
switch (nodeNameLower)
{
case "template":
case "answer": //CML
tagHandlerU = new template(targetBot, user, query, request, result, node);
break;
case "aiml":
case "cml": //CML
tagHandlerU = new aiml(targetBot, user, query, request, result, node);
break;
case "aimlexec":
case "eval":
tagHandlerU = new aimlexec(targetBot, user, query, request, result, node);
break;
case "vars":
case "root":
case "predicates": //CML
tagHandlerU = new root(targetBot, user, query, request, result, node, (() => query.TargetSettings));
break;
case "properties":
case "bots":
tagHandlerU = new root(targetBot, user, query, request, result, node,
(() => request.TargetBot.GlobalSettings));
break;
case "substitutions":
tagHandlerU = new root(targetBot, user, query, request, result, node,
(() => request.TargetBot.InputSubstitutions));
break;
case "topic":
case "conversation": //CML
tagHandlerU = new topic(targetBot, user, query, request, result, node);
break;
case "category":
case "conv": //CML
tagHandlerU = new category(targetBot, user, query, request, result, node);
break;
case "and":
tagHandlerU = new and(targetBot, user, query, request, result, node);
break;
case "or":
tagHandlerU = new or(targetBot, user, query, request, result, node);
break;
case "optional":
tagHandlerU = new optional(targetBot, user, query, request, result, node);
break;
case "isa":
tagHandlerU = new isa(targetBot, user, query, request, result, node);
break;
case "bot":
tagHandlerU = new bot(targetBot, user, query, request, result, node);
break;
case "condition":
case "options": //cml
tagHandlerU = new condition_aima(targetBot, user, query, request, result, node);
break;
case "li":
if (liText)
{
tagHandlerU = new liif(targetBot, user, query, request, result, node);
}
break;
case "if":
tagHandlerU = new liif(targetBot, user, query, request, result, node);
break;
case "personf":
tagHandlerU = new format(targetBot, user, query, request, result, node,
new Func <string, string>(HttpUtility.UrlEncode),
null);
break;
case "date":
tagHandlerU = new date(targetBot, user, query, request, result, node);
break;
case "formal":
tagHandlerU = new formal(targetBot, user, query, request, result, node);
break;
case "gender":
tagHandlerU = new gender(targetBot, user, query, request, result, node);
break;
case "get":
tagHandlerU = new get(targetBot, user, query, request, result, node);
break;
case "gossip":
tagHandlerU = new gossip(targetBot, user, query, request, result, node);
break;
case "get_ip":
case "id":
tagHandlerU = new id(targetBot, user, query, request, result, node);
break;
case "inputreq":
tagHandlerU = new inputreq(targetBot, user, query, request, result, node);
break;
case "request":
tagHandlerU = new input(targetBot, user, query, request, result, node, 1);
break;
case "input":
tagHandlerU = new input(targetBot, user, query, request, result, node, 1);
break;
case "justthat": // <input index="2"/>
tagHandlerU = new input(targetBot, user, query, request, result, node, 2);
break;
case "beforethat": // <input index="3"/>
tagHandlerU = new input(targetBot, user, query, request, result, node, 3);
break;
#if !(__MonoCS__)
case "javascript":
tagHandlerU = new javascript(targetBot, user, query, request, result, node);
break;
#endif
case "learn":
case "load":
case "noload": // the commented version of <load>
tagHandlerU = new learn(targetBot, user, query, request, result, node);
break;
case "lowercase":
tagHandlerU = new lowercase(targetBot, user, query, request, result, node);
break;
case "person":
tagHandlerU = new substitute(targetBot, user, query, request, result, node);
break;
case "person2":
tagHandlerU = new substitute(targetBot, user, query, request, result, node);
break;
case "random":
tagHandlerU = new random(targetBot, user, query, request, result, node);
break;
case "sentence":
tagHandlerU = new sentence(targetBot, user, query, request, result, node);
break;
case "set":
tagHandlerU = new set(targetBot, user, query, request, result, node);
break;
case "size":
case "getsize":
tagHandlerU = new size(targetBot, user, query, request, result, node);
break;
case "sr":
tagHandlerU = new sr(targetBot, user, query, request, result, node);
break;
case "srai_odd":
tagHandlerU = new srai_odd(targetBot, user, query, request, result, node);
break;
case "star":
tagHandlerU = new star(targetBot, user, query, request, result, node);
break;
case "system":
tagHandlerU = new system(targetBot, user, query, request, result, node);
break;
case "that": //default <that index="1,1"/>
tagHandlerU = new that(targetBot, user, query, request, result, node, 1);
break;
case "justbeforethat": //treated as <that index="2,1"/>
tagHandlerU = new that(targetBot, user, query, request, result, node, 2);
break;
case "response": //treated as <that index="1,1"/>
tagHandlerU = new that(targetBot, user, query, request, result, node, 2);
break;
case "thatstar":
tagHandlerU = new thatstar(targetBot, user, query, request, result, node);
break;
case "think":
tagHandlerU = new think(targetBot, user, query, request, result, node);
break;
case "topicstar":
tagHandlerU = new topicstar(targetBot, user, query, request, result, node);
break;
case "uppercase":
tagHandlerU = new uppercase(targetBot, user, query, request, result, node);
break;
case "version":
case "getversion":
tagHandlerU = new version(targetBot, user, query, request, result, node);
break;
case "cycsystem":
tagHandlerU = new cycsystem(targetBot, user, query, request, result, node);
break;
case "cycretract":
tagHandlerU = new cycretract(targetBot, user, query, request, result, node);
break;
case "cycassert":
tagHandlerU = new cycassert(targetBot, user, query, request, result, node);
break;
case "cycterm":
tagHandlerU = new cycterm(targetBot, user, query, request, result, node);
break;
case "cycquery":
tagHandlerU = new cycquery(targetBot, user, query, request, result, node);
break;
case "cyccondition":
tagHandlerU = new cyccondition(targetBot, user, query, request, result, node);
break;
case "cycphrase":
tagHandlerU = new cycphrase(targetBot, user, query, request, result, node);
break;
case "cycparaphrase":
tagHandlerU = new cycphrase(targetBot, user, query, request, result, node);
break;
case "guard":
tagHandlerU = new guard(targetBot, user, query, request, result, node);
break;
case "guardstar":
tagHandlerU = new guardstar(targetBot, user, query, request, result, node);
break;
case "cycrandom":
tagHandlerU = new cycrandom(targetBot, user, query, request, result, node);
break;
case "tscore":
tagHandlerU = new tscore(targetBot, user, query, request, result, node);
break;
case "space":
tagHandlerU = new space(targetBot, user, query, request, result, node);
break;
case "markov":
tagHandlerU = new markov(targetBot, user, query, request, result, node);
break;
case "soundcode":
tagHandlerU = new soundcode(targetBot, user, query, request, result, node);
break;
// MSM
case "msm":
tagHandlerU = new msm(targetBot, user, query, request, result, node);
break;
case "processmsm":
tagHandlerU = new process_msm(targetBot, user, query, request, result, node);
break;
case "setstate":
tagHandlerU = new setstate(targetBot, user, query, request, result, node);
break;
case "state":
tagHandlerU = new state(targetBot, user, query, request, result, node);
break;
case "transition":
tagHandlerU = new transition(targetBot, user, query, request, result, node);
break;
case "setevidence":
tagHandlerU = new setevidence(targetBot, user, query, request, result, node);
break;
case "evidenceassoc":
tagHandlerU = new evidence_assoc(targetBot, user, query, request, result, node);
break;
case "evidencepattern":
tagHandlerU = new evidence_pattern(targetBot, user, query, request, result, node);
break;
case "evidencestate":
tagHandlerU = new evidencestate(targetBot, user, query, request, result, node);
break;
case "dependentmachine":
tagHandlerU = new dependentmachine(targetBot, user, query, request, result, node);
break;
case "responsetopic":
tagHandlerU = new response_topic(targetBot, user, query, request, result, node);
break;
case "push":
tagHandlerU = new push(targetBot, user, query, request, result, node);
break;
case "pop":
tagHandlerU = new pop(targetBot, user, query, request, result, node);
break;
case "peekstack":
tagHandlerU = new peekstack(targetBot, user, query, request, result, node);
break;
case "lex":
tagHandlerU = new lex(targetBot, user, query, request, result, node);
break;
case "lexset":
tagHandlerU = new lexset(targetBot, user, query, request, result, node);
break;
case "lexis":
tagHandlerU = new lexis(targetBot, user, query, request, result, node);
break;
case "dbpush":
tagHandlerU = new dbpush(targetBot, user, query, request, result, node);
break;
case "dbquery":
tagHandlerU = new dbquery(targetBot, user, query, request, result, node);
break;
case "dbupdate":
tagHandlerU = new dbupdate(targetBot, user, query, request, result, node);
break;
case "dbdelete":
tagHandlerU = new dbdelete(targetBot, user, query, request, result, node);
break;
case "dbload":
tagHandlerU = new dbload(targetBot, user, query, request, result, node);
break;
case "regex":
tagHandlerU = new regex(targetBot, user, query, request, result, node);
break;
case "bind": // <bind>#$isa</bind>
tagHandlerU = new bind(targetBot, user, query, request, result, node);
break;
case "#text":
if (!liText)
{
return(null);
}
return(new verbatum(node.Value, targetBot, user, query, request, result, node));
case "#comment":
return(new verbatum(node.OuterXml, targetBot, user, query, request, result, node));
case "br":
return(new verbatum("\n", targetBot, user, query, request, result, node));
case "pre":
return(new verbatum(StaticXMLUtils.InnerXmlText(node), targetBot, user, query, request, result, node));
case "p":
return(new verbatum("\n\n", targetBot, user, query, request, result, node));
case "meta":
return(new verbatum(node.OuterXml, targetBot, user, query, request, result, node));
default:
break;
}
}
if (tagHandlerU != null)
{
return(tagHandlerU);
}
if (StaticAIMLUtils.IsHtmlTag(node.Name))
{
return(new recursiveVerbatum(node, targetBot, user, query, request, result, node, true));
}
if (tagHandlerU == null)
{
// "bot", "favorite", "fav"
foreach (KeyValuePair <string, string> prefix in new[]
{
new KeyValuePair <string, string>("get_", "get"),
new KeyValuePair <string, string>("set_", "set"),
new KeyValuePair <string, string>("bot_", "bot"),
new KeyValuePair <string, string>("favorite_", "bot"),
new KeyValuePair <string, string>("favorite", "bot"),
new KeyValuePair <string, string>("fav_", "bot"),
new KeyValuePair <string, string>("fav", "bot"),
new KeyValuePair <string, string>("get", "get"),
new KeyValuePair <string, string>("set", "set"),
new KeyValuePair <string, string>("bot", "bot"),
})
{
if (nodeNameLower.StartsWith(prefix.Key) && node.Name.Length > prefix.Key.Length)
{
string name = node.Name.Substring(prefix.Key.Length);
XmlNode pn = node.ParentNode;
LineInfoElementImpl newnode = StaticXMLUtils.CopyNode(prefix.Value, node, false);
XmlAttributeLineInfo atr = (XmlAttributeLineInfo)newnode.OwnerDocument.CreateAttribute("name");
atr.ReadOnly = false;
atr.Value = name;
newnode.Attributes.Append(atr);
if (node.Name.ToLower() != newnode.Name.ToLower())
{
writeToLog("AIMLLOADER: converted " + node.OuterXml + " -> " + newnode.OuterXml);
return(targetBot.GetTagHandler(newnode, query, request, result, user, liText));
}
writeToLog("AIMLLOADER: ! convert " + node.OuterXml + " -> " + newnode.OuterXml);
}
}
}
if (tagHandlerU != null)
{
return(tagHandlerU);
}
if (nodeNameLower == "name")
{
return(new bot(targetBot, user, query, request, result, node));
}
tagHandlerU = new lazyClosure(targetBot, user, query, request, result, node);
writeToLog("AIMLLOADER: lazyClosure: " + node.OuterXml);
return(tagHandlerU);
}
public AIMLTagHandler proccessResponse000(SubQuery query, Request request, Result result,
XmlNode sOutput, Unifiable sGuard,
out bool createdOutput, out bool templateSucceeded,
AIMLTagHandler parentHandlerU, TemplateInfo templateInfo,
bool copyChild, bool copyParent)
{
AltBot Proc = query.TargetBot;
//query.LastTagHandler = handler;
bool isTraced = request.IsTraced || request.IsTraced || !request.GraphsAcceptingUserInput ||
(templateInfo != null && templateInfo.IsTraced);
//XmlNode guardNode = AIMLTagHandler.getNode(s.Guard.InnerXml);
bool usedGuard = sGuard != null && sGuard.PatternNode != null;
sOutput = sOutput ?? templateInfo.ClonedOutput;
string output = sOutput.OuterXml;
XmlNode templateNode = sOutput;
bool childOriginal = true;
result.Started = true;
if (usedGuard)
{
output = "<template>" + sGuard.PatternNode.OuterXml + " GUARDBOM " + output +
"</template>";
templateNode = StaticAIMLUtils.getNodeAndSetSibling(false, output, false, false, sOutput);
childOriginal = false;
}
bool protectChild = copyChild || childOriginal;
bool suspendingLimits = request.IsToplevelRequest || request.SuspendSearchLimits;
AIMLTagHandler tagHandlerU = GetTagHandler(request.Requester, query, request, result,
templateNode, parentHandlerU);
string outputSentenceOut = processNode(templateNode, query,
request, result, request.Requester, parentHandlerU,
protectChild, copyParent, tagHandlerU, suspendingLimits, out templateSucceeded);
templateSucceeded = !StaticAIMLUtils.IsFalse(outputSentenceOut);
if (outputSentenceOut == null)
{
if (tagHandlerU == null)
{
writeToLog("tagHandler = null " + output);
}
else
{
bool success = false;
if (tagHandlerU.QueryHasSuceeded)
{
success = true;
}
if (tagHandlerU.QueryHasFailed)
{
success = false;
}
if (success)
{
writeToLog("Very BaD " + output);
}
else
{
}
templateSucceeded = false;
createdOutput = false;
return(tagHandlerU);
}
}
outputSentenceOut = outputSentenceOut ?? "";
string left, outputSentence;
if (!StaticAIMLUtils.SplitOff(outputSentenceOut, "GUARDBOM", out left, out outputSentence))
{
left = null;
outputSentence = outputSentenceOut;
}
if (sGuard == null || sGuard.PatternNode != null)
{
string o = Proc.ToEnglish(outputSentence);
if (outputSentence.Trim().Length > 0)
{
templateSucceeded = true;
}
if (Proc.IsOutputSentence(o, outputSentence))
{
if (isTraced)
{
string aIMLLoaderParentTextAndSourceInfo = ParentTextAndSourceInfo(templateNode);
if (aIMLLoaderParentTextAndSourceInfo.Length > 300)
{
aIMLLoaderParentTextAndSourceInfo = TextFilter.ClipString(
aIMLLoaderParentTextAndSourceInfo, 300);
}
writeToLog("AIMLTRACE '{0}' IsOutputSentence={1}", o, aIMLLoaderParentTextAndSourceInfo);
}
createdOutput = true;
request.AddOutputSentences(templateInfo, o, result, request.TopLevelScore);
}
else
{
createdOutput = false;
}
// @TODO @HACK @BUG isTraced is a HORRID flag here!
if (false && !createdOutput && isTraced && request.GraphsAcceptingUserInput)
{
if (templateInfo != null)
{
string fromStr = " from " + templateInfo.Graph;
if (!StaticAIMLUtils.IsSilentTag(templateNode))
{
writeToLog("SILENT '{0}' TEMPLATE={1}", o, ParentTextAndSourceInfo(templateNode) + fromStr);
}
request.DisableTemplateUntilFinished(templateInfo);
}
else
{
writeToLog("UNUSED '{0}' TEMPLATE={1}", o, ParentTextAndSourceInfo(templateNode));
}
}
return(tagHandlerU);
}
try
{
templateSucceeded = !StaticAIMLUtils.IsFalse(left);
if (!templateSucceeded)
{
createdOutput = false;
return(tagHandlerU);
}
string lang = StaticXMLUtils.GetAttribValue(sGuard.PatternNode, "lang", "cycl").ToLower();
try
{
Unifiable ss = Proc.SystemExecute(left, lang, request);
if (StaticAIMLUtils.IsFalse(ss) || StaticAIMLUtils.IsNullOrEmpty(ss))
{
if (isTraced)
{
writeToLog("GUARD FALSE '{0}' TEMPLATE={1}", request,
ParentTextAndSourceInfo(templateNode));
}
templateSucceeded = false;
createdOutput = false;
return(tagHandlerU);
}
else
{
templateSucceeded = true;
}
}
catch (ChatSignal e)
{
throw;
}
catch (Exception e)
{
Proc.writeToLog(e);
templateSucceeded = false;
createdOutput = false;
return(tagHandlerU);
}
//part the BOM
string o = Proc.ToEnglish(outputSentence);
if (Proc.IsOutputSentence(o, outputSentence))
{
if (isTraced)
{
writeToLog(query.Graph + ": GUARD SUCCESS '{0}' TEMPLATE={1}", o,
ParentTextAndSourceInfo(templateNode));
}
templateSucceeded = true;
createdOutput = true;
request.AddOutputSentences(templateInfo, o, result, request.TopLevelScore);
return(tagHandlerU);
}
else
{
writeToLog("GUARD SKIP '{0}' TEMPLATE={1}", outputSentence,
ParentTextAndSourceInfo(templateNode));
}
templateSucceeded = false;
createdOutput = false;
return(tagHandlerU);
}
catch (ChatSignal e)
{
throw;
}
catch (Exception ex)
{
Proc.writeToLog(ex);
templateSucceeded = false;
createdOutput = false;
return(tagHandlerU);
}
}
static public void writeToLog(string message, params object[] args)
{
AltBot.writeDebugLine(message, args);
}
public void startRobot(string myName)
{
//if (servitor == null)
{
AltBot.ConsoleRobot = MyAltBot = MyBot ?? AltBot.ConsoleRobot ?? new AltBot();
try
{
MyAltBot.ObjectRequester = (ICollectionRequester)colreq;
MyBot.outputDelegate = WriteLine;
MyAltBot.SetName(myName);
MyBot.sayProcessor = new sayProcessorDelegate(TalkActive);
}
catch (Exception e)
{
WriteLine("ERROR {0}", e);
}
//servitor = MyBot.servitor ?? new Servitor(MyBot, null, true, true, true);
//Console.WriteLine("*** Created WN ***");
MyAltBot.isAcceptingUserInput = false;
MyBot.sayProcessor = new sayProcessorDelegate(sayConsole);
MyBot.useMemcache = true;
Console.WriteLine("WebServitor.serverRoot ={0}", WebServitor.serverRoot);
Console.WriteLine("servitor.rapStoreDirectory (STEM) ={0}", servitor.rapStoreDirectory);
//servitorbin = @"C:\RD4541\Acore\RealBot\RealBot2\RealBot2\RealBot2\bin\Debug\aiml\kotoko_irata\bin\ki.kvt";
servitorbin = @".\aiml\kotoko_irata\bin\ki.kvt";
curUser = MyBot.LastUser;
//MyBot.myBehaviors.persistantDirectory = @"./BHTrees/";
//servitor.setBBHash("aimlinstancedir", @"C:\RD4541\Acore\RealBot\RealBot2\RealBot2\RealBot2\bin\Debug\aiml\kotoko_irata");
// if (File.Exists(servitorbin))
if (0 == 1)
{
// Load the previous binary data
servitor.loadFromBinaryFile(servitorbin);
servitor.skiploadingAimlFiles = true;
}
else
{
// Load the AIML then save the binary
//MyBot.loadAIMLFromFiles(@"C:\RD4541\Acore\RealBot\RealBot2\RealBot2\RealBot2\bin\Debug\aiml\kotoko_irata");
// MyBot.rapStoreDirectory = null;
//MyBot.loadAIMLFromFiles(@"./aiml/chomskyAIML");
//MyBot.loadAIMLFromFile(@"./aiml/special/blackjack.aiml");
//MyBot.loadAIMLFromFiles(@"./aiml/guest_gurl");
// servitor.saveToBinaryFile(servitorbin);
//servitor.skiploading = true;
}
//reloadServitor();
}
MyBot.useMemcache = true;
// FOR DEBUG
MyBot.inCritical = true;
MyAltBot.isAcceptingUserInput = true;
// FOR TESTING
MyBot.inCritical = false;
MyBot.blockCron = false;
MyAltBot.WriteConfig();
MyBot.servitor.loadComplete();
}
public AIMLScriptIntperForFiletype(string type, AltBot bot)
{
this.Lang = type;
TheBot = bot;
}
public MasterResult(User user, AltAIMLbot.AltBot bot, Request request)
: base(user, bot, request)
{
}
public bool BotUserDirective(User myUser, string input, OutputDelegate console)
{
AltBot myBot = this;
if (input == null)
{
return(false);
}
input = input.Trim();
if (input == "")
{
return(false);
}
if (input.StartsWith("@"))
{
input = input.TrimStart(new[] { ' ', '@' });
}
// myUser = myUser ?? myBot.LastUser ?? myBot.FindOrCreateUser(null);
int firstWhite = input.IndexOf(' ');
if (firstWhite == -1)
{
firstWhite = input.Length - 1;
}
string cmd = input.Substring(0, firstWhite + 1).Trim().ToLower();
string args = input.Substring(firstWhite + 1).Trim();
bool showHelp = false;
if (cmd == "help")
{
showHelp = true;
}
if (showHelp)
{
console("@rmuser <userid> -- removes a users from the user dictionary\n (best if used after a rename)");
}
if (cmd == "rmuser")
{
string name = myBot.KeyFromUsername(args);
if (args != name)
{
console("use @rmuser " + name);
return(true);
}
myBot.RemoveUser(name);
return(true);
}
if (showHelp)
{
console("@setuser <full name> -- Finds or creates and acct and changes the LastUser (current user)");
}
if (cmd == "setuser")
{
myBot.LastUser = myBot.FindOrCreateUser(args);
return(true);
}
if (showHelp)
{
console(
"@chuser <full name> [- <old user>] -- 'old user' if not specified, uses LastUser. \n Changes the LastUser (current user) and copies the user settings if the old acct was a 'role acct' and reloads the prevoius role settings.");
}
if (cmd == "chuser")
{
string oldUser = null; // myUser ?? LastUser.ShortName ?? "";
string newUser = args;
int lastIndex = args.IndexOf("-");
if (lastIndex > 0)
{
oldUser = args.Substring(lastIndex).Trim();
newUser = args.Substring(0, lastIndex).Trim();
}
myBot.LastUser = myBot.ChangeUser(oldUser, newUser);
return(true);
}
if (showHelp)
{
console(
"@rename <full name> [- <old user>] -- if 'old user' if not specified, uses LastUser.\n if the old user is a role acct, then is the same as @chuser (without resetting current user). otherwise creates a dictionary alias ");
}
if (cmd == "rename")
{
string user, value;
int found = DivideString(args, "-", out user, out value);
if (found == 1)
{
value = myUser.UserID;
}
else
{
if (found == 0)
{
console("use: @rename <full name> [- <old user>]");
}
}
myBot.RenameUser(value, user);
console("Renamed: " + user + " is now known to be " + value);
return(true);
}
if (showHelp)
{
console("@users --- lists users");
}
if (cmd == "users")
{
console("-----------------------------------------------------------------");
console("------------BEGIN USERS----------------------------------");
lock (myBot.BotUsers)
lock (microBotUsersLock) foreach (KeyValuePair <string, User> kv in myBot.BotUsers)
{
console("-----------------------------------------------------------------");
WriteUserInfo(console, "key=" + kv.Key, kv.Value);
console("-----------------------------------------------------------------");
}
console("------------ENDS USERS----------------------------------");
console("-----------------------------------------------------------------");
WriteUserInfo(console, "LastUser: "******"Command caller: ", myUser);
console("-----------------------------------------------------------------");
return(true);
}
if (cmd.Contains("jmx"))
{
writeToLog("JMXTRACE: " + args);
return(true);
}
return(false);
}
public void advanceBotMachine(AltBot bot0)
{
BehaviorContext bot = bot0.BotBehaving;
string nextState = curState;
XmlNodeList rules = rulesDoc.SelectNodes(String.Format(ruleMatch, curState));
XmlNode node = rules[0];
XmlNode lastTransition = null;
Int32 elapsedTime = Environment.TickCount - transitionTime;
foreach (XmlNode transition in node.SelectNodes(allTransitionsInARuleMatch))
{
string targetStateName = transition.Attributes["target"].Value;
string eventData = transition.Attributes["event"] == null ? null : transition.Attributes["event"].Value;
string condData = transition.Attributes["cond"] == null ? null : transition.Attributes["cond"].Value;
string [] parms = condData.Trim().Split(' ');
string varName = parms[0];
string rel = parms[1].ToLower();
string val = parms[2];
double dval = 0;
try
{
dval = double.Parse(val);
}
catch (Exception e)
{
dval = 0;
}
// Fetch conditional test
// Checking blackboard/cache but should include
// bot predicates,cache, chemistry
string sv = null;
double bbVal = 0;
try
{
//sv = myChemistry.m_cBus.getHash("mdollhearduuid");
sv = bot.getBBHash(varName);
if (!string.IsNullOrEmpty(sv))
{
bbVal = double.Parse(sv);
}
}
catch (Exception e) { }
// Special variables?
if (varName == "timeout")
{
bbVal = elapsedTime;
}
if (varName == "prob")
{
bbVal = rgen.NextDouble();
}
// Check Condition
bool valid = false;
Match match = null;
switch (rel)
{
case "==":
valid = (bbVal == dval);
break;
case "<":
valid = (bbVal < dval);
break;
case ">":
valid = (bbVal > dval);
break;
case "lt":
valid = (bbVal < dval);
break;
case "gt":
valid = (bbVal > dval);
break;
case "<=":
valid = (bbVal <= dval);
break;
case ">=":
valid = (bbVal >= dval);
break;
case "matches":
match = (new Regex(val)).Match(sv);
valid = match.Success;
break;
case "!matches":
match = (new Regex(val)).Match(sv);
valid = !match.Success;
break;
case "notmatches":
match = (new Regex(val)).Match(sv);
valid = !match.Success;
break;
case "=~":
match = (new Regex(val)).Match(sv);
valid = match.Success;
break;
case "!~":
match = (new Regex(val)).Match(sv);
valid = !match.Success;
break;
}
if (varName == "TRUE")
{
valid = true;
}
// Stop on first so store in priority order
// The alternative is to keep a success stack
if (valid)
{
lastTransition = transition;
nextState = targetStateName;
break;
}
}
// Quit on no transition
if (nextState == curState)
{
return;
}
Console.WriteLine("FSM: {0}-->{1}", curState, nextState);
// Run OnExit
processOnExit(curState, bot);
//Run Transition
processTransition(lastTransition, bot);
// Run OnEntry
processOnEntry(nextState, bot);
// Transition
curState = nextState;
transitionTime = Environment.TickCount;
bot.setBBHash("fsmstate", curState);
}
