public Empty()
{
Name = "empty";
Grammars.Add("<noun>", EmptyObject);
Grammars.Add("out <noun>", EmptyObject);
Grammars.Add("<noun> out", EmptyObject);
}
public Ask()
{
Name = "ask";
//Grammars.Add("<creature> 'about' <topic>", AttackObject);
Grammars.Add("<noun> 'about' <topic>", OnAsk);
Grammars.Add("<noun> 'for' <noun>", OnAskFor);
}
public Open()
{
Name = "open";
Synonyms.Are("open, uncover, undo, unwrap");
Grammars.Add("<noun>", OpenObject);
Grammars.Add("<noun> with <held>", UnlockObject);
}
public SwitchOn()
{
Name = "switch";
Grammars.Add("<noun>", SwitchOnObject);
Grammars.Add("<noun> on", SwitchOnObject);
Grammars.Add("on <noun>", SwitchOnObject);
}
protected bool _Next(AttrTree r, int i, List <string> result)
{
bool res = false;
for (; i < r.Count; i++)
{ // loop until not optional
AttrTree g = (AttrTree)r[i];
if (Grammars.ContainsKey(g.Node))
{
foreach (AttrTree alt in (AttrTree)Grammars[g.Node])
{
if (_Next(alt, 0, result))
{
res = true;
}
}
}
else
{
if (!result.Contains(g.Node))
{
result.Add(g.Node);
}
res = true;
}
if (!g.IsOptional)
{
break;
}
}
return(res);
}
private void OnListGrammars(Grammars response, Dictionary <string, object> customData)
{
Log.Debug("TestSpeechToText.OnListGrammars()", "{0}", customData["json"].ToString());
Test(response != null);
Test(response._Grammars != null);
_listGrammarsTested = true;
}
public Pick()
{
Name = "pick up";
Synonyms.Are("pick");
Grammars.Add("up <multi>", PickUpObject);
Grammars.Add("<multi> up", PickUpObject);
}
// Use this for initialization
void Awake()
{
grammars = JsonUtility.FromJson <Grammars>(loadJSON());
tags = new string[] { "nouns", "adjectives", "verbs", "adverbs", "number" };
//ChangeText();
//InvokeRepeating("ChangeText", 1.0f, 2.0f);
}
public Remove()
{
Name = "remove";
//Synonyms.Are("take", "carry", "hold");
Grammars.Add(K.HELD_TOKEN, Disrobe);
Grammars.Add(K.MULTI_TOKEN, Take);
}
public Go()
{
Name = "go";
Synonyms.Are("g", "walk", "run");
Grammars.Add(Grammar.Empty, VagueGo);
Grammars.Add(K.DIRECTION_TOKEN, () => false);
Grammars.Add(K.NOUN_TOKEN, EnterIt);
}
public Close()
{
Name = "close";
Synonyms.Are("cover", "shut");
Grammars.Add("<noun>", CloseObject);
Grammars.Add("up <noun>", CloseObject);
Grammars.Add("off <noun>", SwitchOffObject);
}
public Look()
{
Name = "look";
Synonyms.Are("l");
Grammars.Add(Grammar.Empty, LookAtRoom);
Grammars.Add("at <noun>", ExamineObject);
Grammars.Add("<noun>", ExamineObject);
}
public Put()
{
Name = "put";
Grammars.Add("<multi> in <noun>", InsertObject);
Grammars.Add("<multiheld> on <noun>", PutOnObject);
Grammars.Add("on <held>", WearObject);
Grammars.Add("down <multiheld>", DropObject);
Grammars.Add("<multiheld> down", DropObject);
}
public Put()
{
Name = "put";
Grammars.Add("<multi> [in,inside,into] <noun>", InsertObject);
Grammars.Add("<multiheld> [on,onto] <noun>", PutOnObject);
Grammars.Add("on <held>", WearObject);
Grammars.Add("down <multiheld>", DropObject);
Grammars.Add("<multiheld> down", DropObject);
}
public Turn()
{
Name = "turn";
Synonyms.Are("turn", "rotate", "screw", "twist", "unscrew");
Grammars.Add("<noun>", TurnObject);
Grammars.Add("<noun> on", SwitchOnObject);
Grammars.Add("<noun> off", SwitchOffObject);
Grammars.Add("on <noun>", SwitchOnObject);
Grammars.Add("off <noun>", SwitchOffObject);
}
public void preposition_gets_set()
{
var grammars = new Grammars
{
{"<multi> [in,inside,into] <noun>", () => true}
};
var grammar = grammars.Single(x => x.Preposition == "in");
grammar = grammars.Single(x => x.Preposition == "inside");
grammar = grammars.Single(x => x.Preposition == "into");
}
public void Prepare(AttrTree tree)
{
Grammars.Clear();
foreach (AttrTree g in tree)
{
Grammars.Add(g.Node, g);
}
foreach (AttrTree g in tree)
{
ScanLexicon(g);
}
}
public static void RebuildParser()
{
var contents = File.ReadAllText(@"..\..\..\SExpression\SExpression.ometacs");
var result = Grammars.ParseGrammarThenOptimizeThenTranslate
<OMetaParser, OMetaOptimizer, OMetaTranslator>
(contents,
p => p.Grammar,
o => o.OptimizeGrammar,
t => t.Trans);
File.WriteAllText(@"..\..\..\SExpression\GeneratedCode\SExpressionParser.cs", result);
}
public void RebuildGitParser()
{
var contents = File.ReadAllText(@"..\..\..\SharpDiff\Parsers\GitDiffParser.ometacs");
var result = Grammars.ParseGrammarThenOptimizeThenTranslate
<OMetaParser, OMetaOptimizer, OMetaTranslator>
(contents,
p => p.Grammar,
o => o.OptimizeGrammar,
t => t.Trans);
File.WriteAllText(@"..\..\..\SharpDiff\Parsers\GitDiffParser.cs", result);
}
public void preposition_gets_set()
{
var grammars = new Grammars
{
{ "<multi> [in,inside,into] <noun>", () => true }
};
var grammar = grammars.Single(x => x.Preposition == "in");
grammar = grammars.Single(x => x.Preposition == "inside");
grammar = grammars.Single(x => x.Preposition == "into");
}
protected void ScanLexicon(AttrTree tree)
{
foreach (var t in tree)
{
if (t.Count > 0)
{
ScanLexicon(t);
}
else if (!Grammars.ContainsKey(t.Node) && !Lexicon.ContainsKey(t.Node))
{
Lexicon.Add(t.Node, null);
}
}
}
static void Main(string[] args)
{
string dir = Directory.GetCurrentDirectory();
string serializationFile = Path.Combine(dir, "states.bin");
if (!File.Exists(serializationFile))
{
MakeStates(serializationFile);
}
else
{
MakeStates(serializationFile);
//LoadStates(serializationFile);
}
ss.SetOutputToDefaultAudioDevice();
CultureInfo ci = new CultureInfo("en-US");
sre = new SpeechRecognitionEngine(ci);
sre.SetInputToDefaultAudioDevice();
sre.SpeechRecognized += sre_SpeechRecognized;
sre.SpeechHypothesized += sre_SpeechHypothesized;
sre.SpeechRecognitionRejected += sre_SpeechRecognitionRejected;
// sre.EndSilenceTimeoutAmbiguous = TimeSpan.FromSeconds(2);
ss.Speak("Ready");
Console.WriteLine("Saying: <Ready>");
while (States.First != null)
{
State state = States.First.Value;
sre = Grammars.GetGrammars(sre, state);
//sre.EmulateRecognizeAsync();
sre.RecognizeAsync(RecognizeMode.Multiple);
Console.WriteLine("Current State: " + States.First.Value.stateName);
while (state.IsCompleted() == false)
{
;
}
sre.RecognizeAsyncStop();
Console.WriteLine(state.stateName + " Completed!");
States.RemoveFirst();
}
Console.Read();
}
protected bool _PartialMatch(AttrTree targ, int i_targ, string[] patt, int i_patt, List <string> result)
{
bool pend = patt.Length <= i_patt;
if (targ.Count <= i_targ)
{
return(pend);
}
if (pend)
{
return(_Next(targ, i_targ, result));
}
AttrTree goal = (AttrTree)targ[i_targ++];
string word = patt[i_patt];
// word
if (goal.Node.Equals(word))
{
return(_PartialMatch(targ, i_targ, patt, i_patt + 1, result));
}
bool res = goal.IsOptional && _PartialMatch(targ, i_targ, patt, i_patt, result);
// grammar
if (!Grammars.ContainsKey(goal.Node))
{
return(false);
}
AttrTree grm = (AttrTree)Grammars[goal.Node];
// parse all the alternatives
foreach (AttrTree alt in grm)
{
// concatenate clause and the rest of target (after goal) to the new tree
AttrTree temp_targ = new AttrTree(alt);
for (int j = i_targ; j < targ.Count; j++)
{
temp_targ.Add(targ[j]);
}
// try to match
if (_PartialMatch(temp_targ, 0, patt, i_patt, result))
{
res = true;
}
}
return(res);
}
public Disrobe()
{
Synonyms.Are("doff", "shed");
Grammars.Add(K.HELD_TOKEN, OnDisrobe);
}
protected T Parse <T>(string text, Func <GitNumstatParser, Rule <char> > ruleFetcher)
{
return(Grammars.ParseWith(text, ruleFetcher).As <T>());
}
protected IList <T> ParseList <T>(string text, Func <GitNumstatParser, Rule <char> > ruleFetcher)
{
return(new List <T>(Grammars.ParseWith(text, ruleFetcher).ToIEnumerable <T>()));
}
public Enter()
{
Name = "enter";
SetDirection(room => room.IN(), "in");
Grammars.Add("<noun>", EnterObject);
}
public Eat()
{
Name = "eat";
Grammars.Add("<held>", EatObject);
}
public Drop()
{
Name = "drop";
Synonyms.Are("drop", "discard", "throw");
Grammars.Add("<multiheld>", DropObject);
}
protected void ReadFromXml(XmlReader reader)
{
bool inGrammar = false;
Resource resource = null;
Response response = null;
while (reader.Read())
{
switch (reader.Name)
{
case "grammars":
inGrammar = reader.IsStartElement();
break;
case "include":
if (inGrammar && reader.IsStartElement())
{
Grammars.Add(new Include()
{
Href = reader.GetAttribute("href")
});
}
break;
case "resources":
if (reader.IsStartElement())
{
resource = new Resource();
BaseURL = reader.GetAttribute("base");
}
else
{
Resources.Add(resource);
resource = null;
}
break;
case "resource":
if (reader.IsStartElement())
{
resource.Path = reader.GetAttribute("path");
}
break;
case "method":
if (reader.IsStartElement())
{
resource.method = new Method();
resource.method.Name = reader.GetAttribute("name");
resource.method.Id = reader.GetAttribute("id");
}
break;
case "request":
if (reader.IsStartElement())
{
resource.method.request = new Request();
}
break;
case "param":
if (reader.IsStartElement())
{
if (resource.method.request.Params == null)
{
resource.method.request.Params = new List <Param>();
}
resource.method.request.Params.Add(new Param()
{
Name = reader.GetAttribute("name"),
Style = reader.GetAttribute("style"),
Type = reader.GetAttribute("type"),
Required = reader.GetAttribute("required") == "true"
});
}
break;
case "response":
if (reader.IsStartElement())
{
response = new Response();
response.Status = Convert.ToInt32(reader.GetAttribute("status"));
}
else
{
if (resource.method.response == null)
{
resource.method.response = new List <Response>();
}
resource.method.response.Add(response);
}
break;
case "representation":
if (reader.IsStartElement())
{
response.representation = new Representation()
{
MediaType = reader.GetAttribute("mediaType"),
Element = reader.GetAttribute("element")
};
}
break;
}
}
}
public Insert()
{
Name = "insert";
Grammars.Add("<multi> in <noun>", InsertObject);
}
