Пример #1
0
        private void GenerateRuleList(string semantic, string[] alternates, SrgsRuleRef subjectRef = null, DirectObject directObject = null)
        {
            SrgsOneOf commandAlternates = new SrgsOneOf(alternates);
            SrgsItem  command           = new SrgsItem();

            if (subjectRef != null)
            {
                command.Add(new SrgsItem(subjectRef));
                command.Add(new SrgsSemanticInterpretationTag("out.subject=rules.subject;"));
            }

            command.Add(commandAlternates);
            command.Add(new SrgsSemanticInterpretationTag("out.command=\"" + semantic + "\";"));

            if (directObject != null)
            {
                command.Add(directObject.RuleRef);
                command.Add(new SrgsSemanticInterpretationTag("out.directObject=rules." + directObject.RuleName + ";"));
            }

            Item = command;

            RuleList = new List <SrgsRule>();
            SrgsRule rule = new SrgsRule(semantic);

            rule.Add(command);

            RuleList.Add(rule);
            RootRule = rule;
        }
Пример #2
0
        /// <summary>
        /// Parse a ruleref
        /// </summary>
        private IRuleRef ParseRuleRef(SrgsRuleRef srgsRuleRef, IElement parent)
        {
            IRuleRef ruleRef         = null;
            bool     fSpecialRuleRef = true;

            if (srgsRuleRef == SrgsRuleRef.Null)
            {
                ruleRef = _parser.Null;
            }
            else if (srgsRuleRef == SrgsRuleRef.Void)
            {
                ruleRef = _parser.Void;
            }
            else if (srgsRuleRef == SrgsRuleRef.Garbage)
            {
                ruleRef = _parser.Garbage;
            }
            else
            {
                ruleRef         = _parser.CreateRuleRef(parent, srgsRuleRef.Uri, srgsRuleRef.SemanticKey, srgsRuleRef.Params);
                fSpecialRuleRef = false;
            }

            if (fSpecialRuleRef)
            {
                _parser.InitSpecialRuleRef(parent, ruleRef);
            }

            ruleRef.PostParse(parent);
            return(ruleRef);
        }
Пример #3
0
        private void GenerateRuleList(string semantic, string[] alternates, SrgsRuleRef subjectRef = null, DirectObject directObject = null)
        {
            SrgsOneOf commandAlternates = new SrgsOneOf(alternates);
            SrgsItem command = new SrgsItem();

            if (subjectRef != null)
            {
                command.Add(new SrgsItem(subjectRef));
                command.Add(new SrgsSemanticInterpretationTag("out.subject=rules.subject;"));
            }

            command.Add(commandAlternates);
            command.Add(new SrgsSemanticInterpretationTag("out.command=\"" + semantic + "\";"));

            if (directObject != null)
            {
                command.Add(directObject.RuleRef);
                command.Add(new SrgsSemanticInterpretationTag("out.directObject=rules." + directObject.RuleName + ";"));
            }

            Item = command;

            RuleList = new List<SrgsRule>();
            SrgsRule rule = new SrgsRule(semantic);
            rule.Add(command);

            RuleList.Add(rule);
            RootRule = rule;
        }
Пример #4
0
        public void Add(SrgsRuleRef rootRuleRef, IList<SrgsRule> rules)
        {
            if (rootRuleRef != null)
                this.rootRuleRefs.Add(new SrgsItem(rootRuleRef));

            if (rules != null)
            {
                foreach (var r in rules)
                    this.rules.Add(r);
            }
        }
Пример #5
0
        public override Tuple<SrgsRuleRef, IList<SrgsRule>> GetGrammar(IDictionary<string, SrgsRuleRef> refs)
        {
            var numbers = new SrgsOneOf(
                new SrgsItem(
                    new SrgsItem("zero"),
                    new SrgsSemanticInterpretationTag("out = 0")
                ),
                new SrgsItem(
                    new SrgsItem("one"),
                    new SrgsSemanticInterpretationTag("out = 1")
                ),
                new SrgsItem(
                    new SrgsItem("two"),
                    new SrgsSemanticInterpretationTag("out = 2")
                ),
                new SrgsItem(
                    new SrgsItem("three"),
                    new SrgsSemanticInterpretationTag("out = 3")
                ),
                new SrgsItem(
                    new SrgsItem("four"),
                    new SrgsSemanticInterpretationTag("out = 4")
                ),
                new SrgsItem(
                    new SrgsItem("five"),
                    new SrgsSemanticInterpretationTag("out = 5")
                ),
                new SrgsItem(
                    new SrgsItem("six"),
                    new SrgsSemanticInterpretationTag("out = 6")
                ),
                new SrgsItem(
                    new SrgsItem("seven"),
                    new SrgsSemanticInterpretationTag("out = 7")
                ),
                new SrgsItem(
                    new SrgsItem("eight"),
                    new SrgsSemanticInterpretationTag("out = 8")
                ),
                new SrgsItem(
                    new SrgsItem("nine"),
                    new SrgsSemanticInterpretationTag("out = 9")
                )
            );

            var numberRule = new SrgsRule("Number", numbers);
            refs["Number"] = new SrgsRuleRef(numberRule);

            return new Tuple<SrgsRuleRef, IList<SrgsRule>>(
                null,
                new List<SrgsRule> { numberRule }
            );
        }
Пример #6
0
        public void AddGrammarRules(SrgsRulesCollection rules, SrgsOneOf choices)
        {
            var grammarRules = GetGrammarRules();

            if (grammarRules.Length > 0)
            {
                rules.Add(GetGrammarRules());

                var pluginRuleItem = new SrgsItem();
                var refCurrentPluginRule = new SrgsRuleRef(rules.Single(x => x.Id == Id));
                var outPluginRuleItemSemantic = String.Format("out.type=\"{0}\"; out.params=rules.{0};", Id);

                pluginRuleItem.Add(refCurrentPluginRule);
                pluginRuleItem.Add(new SrgsSemanticInterpretationTag(outPluginRuleItemSemantic));

                choices.Add(pluginRuleItem);
            }
        }
Пример #7
0
        public override Tuple<SrgsRuleRef, IList<SrgsRule>> GetGrammar(IDictionary<string, SrgsRuleRef> refs)
        {
            var letters = new SrgsOneOf();
            foreach (var dataPair in this.letters)
            {
                letters.Add(new SrgsItem(
                    new SrgsSemanticInterpretationTag(string.Format("out = '{0}'", dataPair.Value)),
                    new SrgsToken(dataPair.Key)
                ));
            }

            var letterRule = new SrgsRule("Letter", letters);
            refs["Letter"] = new SrgsRuleRef(letterRule);

            return new Tuple<SrgsRuleRef, IList<SrgsRule>>(
                null,
                new List<SrgsRule> { letterRule }
            );
        }
Пример #8
0
        private void GenerateRuleList()
        {
            RuleList = new List<SrgsRule>();

            SrgsOneOf directObject = new SrgsOneOf();

            foreach(directObjectEntry entry in entries)
            {
                SrgsItem item = GetNewNode(entry.alternates, entry.semantic);
                directObject.Add(item);
            }

            RuleList = new List<SrgsRule>();
            SrgsRule rule = new SrgsRule(RuleName);
            rule.Add(directObject);

            RuleRef = new SrgsRuleRef(rule);

            RuleList.Add(rule);
            RootRule = rule;
        }
Пример #9
0
        public override Tuple<SrgsRuleRef, IList<SrgsRule>> GetGrammar(IDictionary<string, SrgsRuleRef> refs)
        {
            var rule = new SrgsRule("YesOrNo",
                new SrgsOneOf(
                    new SrgsItem(
                        new SrgsItem("yes"),
                        new SrgsSemanticInterpretationTag("out = 'yes'")
                    ),
                    new SrgsItem(
                        new SrgsItem("no"),
                        new SrgsSemanticInterpretationTag("out = 'no'")
                    )
                )
            );

            refs["YesOrNo"] = new SrgsRuleRef(rule);

            return new Tuple<SrgsRuleRef, IList<SrgsRule>>(
                null,
                new List<SrgsRule> { rule }
            );
        }
Пример #10
0
        private void GenerateRuleList()
        {
            RuleList = new List <SrgsRule>();

            SrgsOneOf directObject = new SrgsOneOf();

            foreach (directObjectEntry entry in entries)
            {
                SrgsItem item = GetNewNode(entry.alternates, entry.semantic);
                directObject.Add(item);
            }

            RuleList = new List <SrgsRule>();
            SrgsRule rule = new SrgsRule(RuleName);

            rule.Add(directObject);

            RuleRef = new SrgsRuleRef(rule);

            RuleList.Add(rule);
            RootRule = rule;
        }
Пример #11
0
 public Command(string semantic, string[] alternates, IEnumerable<OutputBase> keyList, SrgsRuleRef subjectRef, DirectObject directObject)
 {
     GenerateRuleList(semantic, alternates, subjectRef, directObject);
     GenerateKeyLookup(semantic, keyList, directObject);
 }
Пример #12
0
        /// <summary>
        /// is used by the algorithm to build the super wildcard grammar
        /// </summary>
        /// <param name="readPath">
        /// location of the wildcard.txt file which contains all possible phoneme combinations
        /// </param>
        /// <returns>
        /// a document object representing the grammar
        /// </returns>
        public static SrgsDocument getInitialGrammar()
        {
            Console.WriteLine("Building initial grammar...");

            // set up basic wildcard rule
            SrgsOneOf wildOneOf = new SrgsOneOf();

            // read phoneme wildcard from text file. all combinations are then added to the basic rule
            // string[] sfdasf = System.IO.File.ReadAllLines(readPath);
            // StreamReader rd = new StreamReader(readPath);
            // string allWords = rd.ReadToEnd();
            //string wildcardFile = lex4all.Properties.Resources.en_US_wildcard;

            //string[] words = wildcardFile.Split(new string[] {"\r\n"}, StringSplitOptions.RemoveEmptyEntries);
            string[] words = wildcardFile.Split(new char[0], StringSplitOptions.RemoveEmptyEntries);
            Debug.WriteLine(String.Format("After split, words has length {0}", words.Length));
            foreach (string word in words)
            {
                if (word.Contains("\n"))
                {
                    Debug.WriteLine(String.Format("Found a newline in line {0}", word));
                    break;
                }
                else
                {
                    // make grammar item/token for each wildcard "word"
                    string    pron      = word;
                    string    text      = word.Replace(" ", ".");
                    SrgsToken thisToken = new SrgsToken(text);
                    thisToken.Pronunciation = pron;
                    SrgsItem thisItem = new SrgsItem();
                    thisItem.Add(thisToken);
                    wildOneOf.Add(thisItem);
                    Debug.WriteLine(String.Format("Wrote {0} to wildOneOf", word));
                }
            }

            // create grammar rules
            SrgsRule wildRule = new SrgsRule("Wildcard");

            wildRule.Scope = SrgsRuleScope.Public;
            wildRule.Elements.Add(wildOneOf);
            SrgsRule superRule = new SrgsRule("SuperWildcard");

            superRule.Scope = SrgsRuleScope.Public;
            SrgsRuleRef wildRef   = new SrgsRuleRef(wildRule);
            SrgsItem    superItem = new SrgsItem(0, 10);

            superItem.Add(wildRef);
            superRule.Elements.Add(superItem);

            // create document and add rules
            SrgsDocument gramDoc = new SrgsDocument();

            //Dynamically allocate the  correct phonetic alphabet depending on the language of choice
            if (EngineControl.Language.Equals("zh-CN") || EngineControl.Language.Equals("de-DE"))
            {
                gramDoc.PhoneticAlphabet = SrgsPhoneticAlphabet.Sapi;
                phoneticAlphabet         = "sapi";
            }
            else if (EngineControl.Language.Equals("ja-JP"))
            {
                gramDoc.PhoneticAlphabet = SrgsPhoneticAlphabet.Ipa;
                phoneticAlphabet         = "ipa";
            }
            else

            {
                gramDoc.PhoneticAlphabet = SrgsPhoneticAlphabet.Ups; // This is the default phonetic alphabet setting
                phoneticAlphabet         = "ups";
            }


            gramDoc.Culture = new System.Globalization.CultureInfo(EngineControl.Language);
            gramDoc.Rules.Add(new SrgsRule[] { superRule, wildRule });
            gramDoc.Root = superRule;

            // report
            Console.WriteLine(String.Format("Done. Grammar language is {0}", gramDoc.Culture));

            // output initial grammar
            Console.WriteLine("");
            return(gramDoc);
        }
Пример #13
0
        public static SrgsDocument BuildSrgsGrammar(CultureInfo cultureInfo)
        {
            SrgsDocument document = new SrgsDocument();
            document.Culture = cultureInfo;

            // make a new subject item and then add all of it's rules to the document
            subjectObject = new Subject();
            foreach(SrgsRule rule in subjectObject.RuleList)
            {
                document.Rules.Add(rule);
            }

            SrgsRuleRef subjectRef = new SrgsRuleRef(subjectObject.RootRule);

            // go through and add all of the commands
            commandObjects = new Dictionary<string, Command>();
            SrgsOneOf commandSet = new SrgsOneOf();

            // add just the subjects
            SrgsItem select = new SrgsItem();
            select.Add(new SrgsItem(subjectRef));
            select.Add(new SrgsSemanticInterpretationTag("out.subject=rules.subject;"));
            commandSet.Add(select);

            #region Commands
            #region Move (1)
            // return to formation (1)
            Command returnToFormation = new Command("FORMUP", new string[] { "return to formation", "form up", "fallback", "fall back", "regroup", "join up", "rally on me", "rally to me" }, new uint[] { Keys.One, Keys.One }, subjectRef);
            commandObjects.Add("FORMUP", returnToFormation);
            commandSet.Add(returnToFormation.Item);

            // advance (2)
            Command advance = new Command("ADVANCE", new string[] { "advance", "move up" }, new uint[] { Keys.One, Keys.Two }, subjectRef);
            commandObjects.Add("ADVANCE", advance);
            commandSet.Add(advance.Item);

            // stay back (3)
            Command stayBack = new Command("STAYBACK", new string[] { "stay back", "go back", "back up" }, new uint[] { Keys.One, Keys.Three }, subjectRef);
            commandObjects.Add("STAYBACK", stayBack);
            commandSet.Add(stayBack.Item);

            // flank left (4)
            Command flankLeft = new Command("FLANKLEFT", new string[] { "flank left", "go left" }, new uint[] { Keys.One, Keys.Four }, subjectRef);
            commandObjects.Add("FLANKLEFT", flankLeft);
            commandSet.Add(flankLeft.Item);

            // flank right (5)
            Command flankRight = new Command("FLANKRIGHT", new string[] { "flank right", "go right" }, new uint[] { Keys.One, Keys.Five }, subjectRef);
            commandObjects.Add("FLANKRIGHT", flankRight);
            commandSet.Add(flankRight.Item);

            // stop (6)
            Command stop = new Command("STOP", new string[] { "stop", "hold position", "halt", "stay there", "stay here" }, new uint[] { Keys.One, Keys.Six }, subjectRef);
            commandObjects.Add("STOP", stop);
            commandSet.Add(stop.Item);

            // Wait for me (7)
            Command waitForMe = new Command("WAIT", new string[] { "wait for me", "wait up", "wait" }, new uint[] { Keys.One, Keys.Seven }, subjectRef);
            commandObjects.Add("WAIT", waitForMe);
            commandSet.Add(waitForMe.Item);

            // Find cover (8)
            Command cover = new Command("COVER", new string[] { "go for cover", "look for cover", "cover", "find cover", "get to cover", "hide" }, new uint[] { Keys.One, Keys.Eight }, subjectRef);
            commandObjects.Add("COVER", cover);
            commandSet.Add(cover.Item);

            // Next waypoint (9)
            Command nextWaypoint = new Command("NEXTWAYPOINT", new string[] { "next waypoint", "go to the next waypoint" }, new uint[] { Keys.One, Keys.Nine }, subjectRef);
            commandObjects.Add("NEXTWAYPOINT", nextWaypoint);
            commandSet.Add(nextWaypoint.Item);
            #endregion

            #region Target (2)
            // open menu
            Command openTargetMenu = new Command("OPENTARGET", new string[] { "show targets", "target menu", "open target menu", "targets" }, new uint[] { Keys.Two }, subjectRef);
            commandObjects.Add("OPENTARGET", openTargetMenu);
            commandSet.Add(openTargetMenu.Item);

            // cancel target (1)
            Command cancelTarget = new Command("CANCELTARGET", new string[] { "cancel target", "cancel targets", "no target" }, new uint[] { Keys.Two, Keys.One }, subjectRef);
            commandObjects.Add("CANCELTARGET", cancelTarget);
            commandSet.Add(cancelTarget.Item);
            #endregion

            #region Engage (3)
            // open fire (1)
            Command openFire = new Command("OPENFIRE", new string[] { "open fire", "go loud", "fire at will" }, new uint[] { Keys.Three, Keys.One }, subjectRef);
            commandObjects.Add("OPENFIRE", openFire);
            commandSet.Add(openFire.Item);

            // hold fire (2)
            Command holdFire = new Command("HOLDFIRE", new string[] { "hold fire", "go quiet", "cease fire" }, new uint[] { Keys.Three, Keys.Two }, subjectRef);
            commandObjects.Add("HOLDFIRE", holdFire);
            commandSet.Add(holdFire.Item);

            // fire (3)
            Command fire = new Command("FIRE", new string[] { "fire", "take the shot" }, new uint[] { Keys.Three, Keys.Three }, subjectRef);
            commandObjects.Add("FIRE", fire);
            commandSet.Add(fire.Item);

            // engage (4)
            Command engage = new Command("ENGAGE", new string[] { "engage", "move to engage" }, new uint[] { Keys.Three, Keys.Four }, subjectRef);
            commandObjects.Add("ENGAGE", engage);
            commandSet.Add(engage.Item);

            // engage at will (5)
            Command enageAtWill = new Command("ENGAGEATWILL", new string[] { "engage at will" }, new uint[] { Keys.Three, Keys.Five }, subjectRef);
            commandObjects.Add("ENGAGEATWILL", enageAtWill);
            commandSet.Add(enageAtWill.Item);

            // disengage (6)
            Command disengage = new Command("DISENGAGE", new string[] { "disengage" }, new uint[] { Keys.Three, Keys.Six }, subjectRef);
            commandObjects.Add("DISENGAGE", disengage);
            commandSet.Add(disengage.Item);

            // scan horizon (7)
            Command scanHorizon = new Command("SCANHORIZON", new string[] { "scan horizon", "scan the horizon" }, new uint[] { Keys.Three, Keys.Seven }, subjectRef);
            commandObjects.Add("SCANHORIZON", scanHorizon);
            commandSet.Add(scanHorizon.Item);

            // watch direction (8)
            // team direct object
            DirectObject direction = new DirectObject("directionDO");
            direction.Add(new string[] { "north" }, "NORTH", new uint[] { Keys.One });
            direction.Add(new string[] { "north east" }, "NORTHEAST", new uint[] { Keys.Two });
            direction.Add(new string[] { "east" }, "EAST", new uint[] { Keys.Three });
            direction.Add(new string[] { "south east" }, "SOUTHEAST", new uint[] { Keys.Four });
            direction.Add(new string[] { "south" }, "SOUTH", new uint[] { Keys.Five });
            direction.Add(new string[] { "south west" }, "SOUTHWEST", new uint[] { Keys.Six });
            direction.Add(new string[] { "west" }, "WEST", new uint[] { Keys.Seven });
            direction.Add(new string[] { "north west" }, "NORTHWEST", new uint[] { Keys.Eight });

            foreach (SrgsRule rule in direction.RuleList)
            {
                document.Rules.Add(rule);
            }

            Command watch = new Command("WATCH", new string[] { "watch", "watch the"}, new uint[] { Keys.Three, Keys.Eight }, subjectRef, direction);
            commandObjects.Add("WATCH", watch);
            commandSet.Add(watch.Item);

            // suppressive fire (9)
            Command suppresiveFire = new Command("SUPRESS", new string[] { "supppresive fire", "surpress" }, new uint[] { Keys.Three, Keys.Nine }, subjectRef);
            commandObjects.Add("SUPRESS", suppresiveFire);
            commandSet.Add(suppresiveFire.Item);
            #endregion

            #region Mount (4)
            // open mount menu
            Command openMountMenu = new Command("OPENMOUNT", new string[] { "show mount menu", "open mount menu", "show vehicles", "mount menu", "get in vehicle" }, new uint[] { Keys.Four }, subjectRef);
            commandObjects.Add("OPENMOUNT", openMountMenu);
            commandSet.Add(openMountMenu.Item);

            // dismount (1)
            Command dismount = new Command("DISMOUNT", new string[] { "dismount", "get out" }, new uint[] { Keys.Four, Keys.One }, subjectRef);
            commandObjects.Add("DISMOUNT", dismount);
            commandSet.Add(dismount.Item);
            #endregion

            #region Action (6)
            // open menu
            Command openActionMenu = new Command("OPENACTION", new string[] { "show actions", "action menu", "perform action", "do action", "open action menu", "actions" }, new uint[] { Keys.Six }, subjectRef);
            commandObjects.Add("OPENACTION", openActionMenu);
            commandSet.Add(openActionMenu.Item);
            #endregion

            #region Combat Mode (7)
            // stealth (1)
            Command stealth = new Command("STEALTH", new string[] { "stealth", "stealthy", "stealth mode" }, new uint[] { Keys.Seven, Keys.One }, subjectRef);
            commandObjects.Add("STEALTH", stealth);
            commandSet.Add(stealth.Item);

            // combat (2)
            Command combat = new Command("COMBAT", new string[] { "combat", "danger", "combat mode" }, new uint[] { Keys.Seven, Keys.Two }, subjectRef);
            commandObjects.Add("COMBAT", combat);
            commandSet.Add(combat.Item);

            // aware (3)
            Command aware = new Command("AWARE", new string[] { "aware", "alert", "aware mode", "stay sharp", "stay frosty", "stay alert" }, new uint[] { Keys.Seven, Keys.Three }, subjectRef);
            commandObjects.Add("AWARE", aware);
            commandSet.Add(aware.Item);

            // relax (4)
            Command relax = new Command("RELAX", new string[] { "relax", "relaxed mode", "safe" }, new uint[] { Keys.Seven, Keys.Four }, subjectRef);
            commandObjects.Add("RELAX", relax);
            commandSet.Add(relax.Item);

            // stand up (6)
            Command standUp = new Command("STANDUP", new string[] { "stand up", "get up", "stand" }, new uint[] { Keys.Seven, Keys.Six }, subjectRef);
            commandObjects.Add("STANDUP", standUp);
            commandSet.Add(standUp.Item);

            // stay crouched (7)
            Command stayCrouched = new Command("CROUCH", new string[] { "get low", "crouch", "stay crouched", "stay low" }, new uint[] { Keys.Seven, Keys.Seven }, subjectRef);
            commandObjects.Add("CROUCH", stayCrouched);
            commandSet.Add(stayCrouched.Item);

            // go prone (8)
            Command goProne = new Command("PRONE", new string[] { "go prone", "get down", "prone", "hit the dirt", "down" }, new uint[] { Keys.Seven, Keys.Eight }, subjectRef);
            commandObjects.Add("PRONE", goProne);
            commandSet.Add(goProne.Item);

            // copy my stance (9)
            Command copyMyStance = new Command("COPYMYSTANCE", new string[] { "copy my stance", "default stance" }, new uint[] { Keys.Seven, Keys.Nine }, subjectRef);
            commandObjects.Add("COPYMYSTANCE", copyMyStance);
            commandSet.Add(copyMyStance.Item);
            #endregion

            #region Formation (8)
            // column (1)
            Command column = new Command("COLUMN", new string[] { "formation column", "form column"}, new uint[] { Keys.Eight, Keys.One }, subjectRef);
            commandObjects.Add("COLUMN", column);
            commandSet.Add(column.Item);

            // staggered column (2)
            Command staggeredColumn = new Command("STAGGEREDCOLUMN", new string[] { "formation staggered column", "form staggered column" }, new uint[] { Keys.Eight, Keys.Two }, subjectRef);
            commandObjects.Add("STAGGEREDCOLUMN", staggeredColumn);
            commandSet.Add(staggeredColumn.Item);

            // wedge (3)
            Command wedge = new Command("WEDGE", new string[] { "formation wedge", "form wedge" }, new uint[] { Keys.Eight, Keys.Three }, subjectRef);
            commandObjects.Add("WEDGE", wedge);
            commandSet.Add(wedge.Item);

            // echelon left (4)
            Command echelonLeft = new Command("ECHELONLEFT", new string[] { "formation echelon left", "form echelon left" }, new uint[] { Keys.Eight, Keys.Four }, subjectRef);
            commandObjects.Add("ECHELONLEFT", echelonLeft);
            commandSet.Add(echelonLeft.Item);

            // echelon right (5)
            Command echeloneRight = new Command("ECHELONRIGHT", new string[] { "formation echelon right", "form echelon right" }, new uint[] { Keys.Eight, Keys.Five }, subjectRef);
            commandObjects.Add("ECHELONRIGHT", echeloneRight);
            commandSet.Add(echeloneRight.Item);

            // vee (6)
            Command vee = new Command("VEE", new string[] { "formation vee", "form vee" }, new uint[] { Keys.Eight, Keys.Six }, subjectRef);
            commandObjects.Add("VEE", vee);
            commandSet.Add(vee.Item);

            // line (7)
            Command line = new Command("LINE", new string[] { "formation line", "form line" }, new uint[] { Keys.Eight, Keys.Seven }, subjectRef);
            commandObjects.Add("LINE", line);
            commandSet.Add(line.Item);

            // file (8)
            Command file = new Command("FILE", new string[] { "formation file", "form file" }, new uint[] { Keys.Eight, Keys.Eight }, subjectRef);
            commandObjects.Add("FILE", file);
            commandSet.Add(file.Item);

            // diamond (9)
            Command diamond = new Command("DIAMOND", new string[] { "formation diamond", "form diamond" }, new uint[] { Keys.Eight, Keys.Nine }, subjectRef);
            commandObjects.Add("DIAMOND", diamond);
            commandSet.Add(diamond.Item);
            #endregion

            #region Assign Team (9)
            // team direct object
            DirectObject team = new DirectObject("teamDO");
            team.Add(new string[] { "team red", "red" }, "RED", new uint[] { Keys.One });
            team.Add(new string[] { "team green", "green" }, "GREEN", new uint[] { Keys.Two });
            team.Add(new string[] { "team blue", "blue" }, "BLUE", new uint[] { Keys.Three });
            team.Add(new string[] { "team yellow", "yellow" }, "YELLOW", new uint[] { Keys.Four });
            team.Add(new string[] { "team white", "white" }, "WHITE", new uint[] { Keys.Five });

            foreach (SrgsRule rule in team.RuleList)
            {
                document.Rules.Add(rule);
            }

            Command assignTeam = new Command("ASSIGN", new string[] { "assign", "assign to", "add to", "switch to" }, new uint[] { Keys.Nine }, subjectRef, team);
            commandObjects.Add("ASSIGN", assignTeam);
            commandSet.Add(assignTeam.Item);
            #endregion

            // not implemented
            #region WW_AiMenu
            #region Infantry Commands (1)
            // heal up (1)

            // rearm (2)

            // inventory (3)

            // fire on my lead (4)

            // garrison building (5)

            // clear building (6)

            // follow target (7)
            #endregion

            #region WayPoints (4)
            // set waypoints (1)

            // add waypoints (2)

            // move waypoints (3)

            // delete waypoints (4)

            // wait on waypoint (5)

            // cycle waypoint (6)
            #endregion
            #endregion
            #endregion

            // set the root rule to
            SrgsRule commands = new SrgsRule("commands");
            commands.Add(commandSet);

            document.Rules.Add(commands);
            document.Root = commands;

            return document;
        }
Пример #14
0
 public Command(string semantic, string[] alternates, IEnumerable <OutputBase> keyList, SrgsRuleRef subjectRef, DirectObject directObject)
 {
     GenerateRuleList(semantic, alternates, subjectRef, directObject);
     GenerateKeyLookup(semantic, keyList, directObject);
 }
Пример #15
0
        /// <summary>
        /// throughout the algorithm's passes the grammar is updated with the received prefix phonemes
        /// </summary>
        /// <param name="prefixes">phonemes to be added to the front</param>
        /// <param name="doc">the previous grammar</param>
        /// <param name="passNum">the current pass number</param>
        /// <param name="preReadPath">location of an additional grammar file which is smaller to improve computation time</param>
        /// <returns>
        /// an updated grammar
        /// </returns>
        public static SrgsDocument updateGrammar(List <String> prefixes, SrgsDocument doc, int passNum)
        {
            Console.WriteLine("Prefixing grammar with phonemes from pass {0}...", passNum - 1);
            Debug.WriteLine(String.Format("Grammar language is {0}", doc.Culture));

            // read prefix wildcard from text file
            //(this is a smaller wildcard with just 1 and 2 phonemes which, with the prefix, makes up the first word of superwildcard grammar)

            //string prefixWildcardFile = lex4all.Properties.Resources.en_US_prefixwildcard;
            //string[] words = prefixWildcardFile.Split(new string[] { "\r\n" }, StringSplitOptions.RemoveEmptyEntries);
            string[] words = prefixWildcardFile.Split(new char[0], StringSplitOptions.RemoveEmptyEntries);
            Debug.WriteLine(String.Format("After split, words has length {0}", words.Length));

            // set up basic wildcard oneof
            SrgsOneOf prefixOneOf = new SrgsOneOf();

            // make grammar item/token for prefix + each wildcard "word"
            foreach (string prefix in prefixes)
            {
                SrgsToken prefixToken = new SrgsToken(prefix.Replace(" ", "."));
                prefixToken.Pronunciation = prefix;
                SrgsItem prefixItem = new SrgsItem();
                prefixItem.Add(prefixToken);
                prefixOneOf.Add(prefixItem);
                foreach (string word in words)
                {
                    if (word.Contains("\n"))
                    {
                        Console.WriteLine("Found a newline in line {0}", word);
                        break;
                    }
                    string    pron      = prefix + " " + word;
                    string    text      = pron.Replace(" ", ".");
                    SrgsToken thisToken = new SrgsToken(text);
                    thisToken.Pronunciation = pron;
                    SrgsItem thisItem = new SrgsItem();
                    thisItem.Add(thisToken);
                    prefixOneOf.Add(thisItem);
                }
            }

            // create grammar rules
            SrgsRule prefixRule = new SrgsRule("Prefixes" + (passNum - 1).ToString());

            prefixRule.Scope = SrgsRuleScope.Public;
            SrgsItem prefItem = new SrgsItem(prefixOneOf);

            prefixRule.Elements.Add(prefItem);
            SrgsRuleRef prefRef = new SrgsRuleRef(prefixRule);

            SrgsRule    wildRule = doc.Rules["Wildcard"];
            SrgsRuleRef wildRef  = new SrgsRuleRef(wildRule);

            SrgsRule newSuperRule = new SrgsRule("SuperWildcard" + (passNum - 1).ToString());

            newSuperRule.Scope = SrgsRuleScope.Public;
            newSuperRule.Elements.Add(new SrgsItem(prefRef));
            SrgsItem newSuperItem = new SrgsItem(0, 9);

            newSuperItem.Add(wildRef);
            newSuperRule.Elements.Add(newSuperItem);

            // update document by adding prefixed rules
            doc.Rules.Clear();
            doc.Rules.Add(new SrgsRule[] { newSuperRule, prefixRule, wildRule });
            doc.Root = newSuperRule;

            // report
            Console.WriteLine("Done.");

            return(doc);
        }
Пример #16
0
 public Command(string semantic, string[] alternates, ushort[] keyList, SrgsRuleRef subjectRef, DirectObject directObject)
 {
     GenerateRuleList(semantic, alternates, subjectRef, directObject);
     GenerateKeyLookup(semantic, keyList, directObject);
 }
Пример #17
0
 public Command(string semantic, string[] alternates, uint[] keyList, SrgsRuleRef subjectRef, DirectObject directObject)
 {
     GenerateRuleList(semantic, alternates, subjectRef, directObject);
     GenerateKeyLookup(semantic, keyList, directObject);
 }
Пример #18
0
        private void LoadGrammarForEngineAndPlugins()
        {
            var memoryStream = new MemoryStream(Resources.mainDocument);
            var xmlReader = new XmlTextReader(memoryStream);
            var mainDocument = new SrgsDocument(xmlReader);

            //Rule for plugins
            var pluginRules = new SrgsRule("plugin");
            var choices = new SrgsOneOf();
            pluginRules.Add(choices);

            //Main rule (entry point for speech)
            var mainRule = new SrgsRule("main");
            var systemName = new SrgsItem(_config.SpeechRecognitionElement.Name);
            var speakAnything = SrgsRuleRef.Garbage;
            var refPluginRules = new SrgsRuleRef(pluginRules);
            SrgsItem executeCommandRule = null;
            if (!String.IsNullOrWhiteSpace(_config.SpeechRecognitionElement.ExecuteCommandPhrase))
                executeCommandRule = new SrgsItem(_config.SpeechRecognitionElement.ExecuteCommandPhrase);

            //Genere main Rule
            mainRule.Add(systemName);
            mainRule.Add(speakAnything);
            mainRule.Add(refPluginRules);
            mainRule.Add(new SrgsSemanticInterpretationTag("out=rules.plugin;"));
            mainRule.Add(speakAnything);
            if (!String.IsNullOrWhiteSpace(_config.SpeechRecognitionElement.ExecuteCommandPhrase))
                mainRule.Add(executeCommandRule);
            mainRule.Scope = SrgsRuleScope.Private;

            //Here you should add choices to the document per Plugin
            foreach (var plugin in _plugins)
            {
                plugin.AddGrammarRules(mainDocument.Rules, choices);
            }

            mainDocument.Rules.Add(mainRule);
            mainDocument.Rules.Add(pluginRules);
            mainDocument.Root = mainRule;
            mainDocument.Culture = _speechRecognitionEngine.RecognizerInfo.Culture;
            mainDocument.Mode = SrgsGrammarMode.Voice;
            mainDocument.PhoneticAlphabet = SrgsPhoneticAlphabet.Sapi;

            using (var textWriter = new StringWriter())
            {
                using (var xmlWriter = new XmlTextWriter(textWriter))
                {
                    mainDocument.WriteSrgs(xmlWriter);
                    _log.Info(String.Format("Grammar for the recognition engine in the culture {0}, is {1}", _speechRecognitionEngine.RecognizerInfo.Culture.TwoLetterISOLanguageName, textWriter));
                }
            }

            _speechRecognitionEngine.LoadGrammar(new Grammar(mainDocument));
        }
Пример #19
0
 public Command(string semantic, string[] alternates, string instruction, SrgsRuleRef subjectRef)
 {
     GenerateRuleList(semantic, alternates, subjectRef);
     GenerateInstruction(semantic, instruction);
 }
Пример #20
0
        private void Form2_Load(object sender, EventArgs e)
        {
            recEngine = new SpeechRecognitionEngine();

            /*Reglas para Select*/
            SrgsRule  selectRule = new SrgsRule("selectRule");
            SrgsOneOf selectList = new SrgsOneOf(new string[] {
                "selecciona",
                "traeme",
                "busca",
                "obten",
                "muestrame",
                "muestra",
                "imprime",
                "imprimir"
            });

            selectRule.Add(selectList);

            /*Reglas para numero de registros
             * todos, los = all *
             */
            SrgsRule  allRule = new SrgsRule("allRule");
            SrgsOneOf allList = new SrgsOneOf(new string[] {
                "los",
                "todos los"
            });

            allRule.Add(allList);

            /*nombre de la tabla*/
            SrgsRule  tablaRule = new SrgsRule("tablaRule");
            SrgsOneOf tablaList = new SrgsOneOf(new string[] {
                "empleados"
            });

            tablaRule.Add(tablaList);
            SrgsRule  whereRule = new SrgsRule("whereRule");
            SrgsOneOf whereList = new SrgsOneOf(new string[] {
                "igual"
            });

            allRule.Add(allList);


            /*La referencia con una root ruke hace que que las reglas se unana y tengan que tener un
             * orden especifico, quitar o comentar la regla principal y quirar del la creacion del documenteo */
            /*Regla principal*/
            SrgsRule mainRule = new SrgsRule("mainRule");

            mainRule.Scope = SrgsRuleScope.Public;

            /*Unir los select con los all*/
            // Create the "Subject" and "Verb" rule references and add them to the SrgsDocument.
            SrgsRuleRef selectRef = new SrgsRuleRef(selectRule, "theSelect");

            mainRule.Add(selectRef);

            SrgsRuleRef allRef = new SrgsRuleRef(allRule, "theAll");

            mainRule.Add(allRef);

            SrgsRuleRef tablaRef = new SrgsRuleRef(tablaRule, "theTabla");

            mainRule.Add(tablaRef);

            //Creando el documento con las reglas
            SrgsDocument newDocumento = new SrgsDocument();

            newDocumento.Rules.Add(new SrgsRule[] {
                mainRule,
                selectRule,
                allRule,
                tablaRule
            });
            newDocumento.Root = mainRule;

            //Agragar gramatica al engine
            Grammar grammar = new Grammar(newDocumento, "mainRule");

            recEngine.LoadGrammar(grammar);

            //Crear XML
            System.Xml.XmlWriter writer =
                System.Xml.XmlWriter.Create("C:\\Users\\Misael\\Documents\\ejemplo.xml");
            newDocumento.WriteSrgs(writer);
            writer.Close();


            // Attach a handler for the SpeechRecognized event.
            recEngine.SpeechRecognized +=
                new EventHandler <SpeechRecognizedEventArgs>(recEngine_SpeechRecognized);

            // Configure the input to the SpeechRecognitionEngine object.
            recEngine.SetInputToDefaultAudioDevice();

            // Start asynchronous recognition.
            recEngine.RecognizeAsync();
        }
Пример #21
0
        static void Main(string[] args)
        {
            // Create the "Subject" rule.
            SrgsRule  subjRule = new SrgsRule("id_Subject");
            SrgsOneOf subjList = new SrgsOneOf(new string[] { "I", "you", "he", "she", "Tom", "Mary" });

            subjRule.Add(subjList);

            // Create the "Verb" rule.
            SrgsRule  verbRule = new SrgsRule("id_Verb");
            SrgsOneOf verbList = new SrgsOneOf(new string[] { "ate", "bought", "saw", "sold", "wanted" });

            verbRule.Add(verbList);

            // Create the "Object" rule.
            SrgsRule  objRule = new SrgsRule("id_Object");
            SrgsOneOf objList = new SrgsOneOf(new string[] { "apple", "banana", "pear", "peach", "melon" });

            objRule.Add(objList);

            // Create the root rule.
            // In this grammar, the root rule contains references to the other three rules.
            SrgsRule rootRule = new SrgsRule("Subj_Verb_Obj");

            rootRule.Scope = SrgsRuleScope.Public;

            // Create the "Subject" and "Verb" rule references and add them to the SrgsDocument.
            SrgsRuleRef subjRef = new SrgsRuleRef(subjRule, "theSubject");

            rootRule.Add(subjRef);

            SrgsRuleRef verbRef = new SrgsRuleRef(verbRule, "theVerb");

            rootRule.Add(verbRef);

            // Add logic to handle articles: "the", "a", "and", occurring zero or one time.
            SrgsOneOf articles = new SrgsOneOf(
                new SrgsItem[] { new SrgsItem(0, 1, "the"), new SrgsItem(0, 1, "a"), new SrgsItem(0, 1, "an") }
                );

            rootRule.Add(articles);

            // Create the "Object" rule reference and add it to the SrgsDocument.
            SrgsRuleRef objRef = new SrgsRuleRef(objRule, "theObject");

            rootRule.Add(objRef);

            // Create an SrgsDocument object that contains all four rules.
            SrgsDocument document = new SrgsDocument();

            document.Rules.Add(rootRule, subjRule, verbRule, objRule);

            // Set "rootRule" as the root rule of the grammar.
            document.Root = rootRule;

            // Create a Grammar object, initializing it with the root rule.
            Grammar g = new Grammar(document, rootRule.Id);

            // Create a new SpeechRecognizer instance.
            SpeechRecognizer sr = new SpeechRecognizer();

            // Load the Grammar object into the recognizer.
            sr.LoadGrammar(g);

            // Produce an XML file that contains the grammar.
            System.Xml.XmlWriter writer = System.Xml.XmlWriter.Create("srgsDocument.xml");
            document.WriteSrgs(writer);
            writer.Close();

            sr.SpeechRecognized += new EventHandler <SpeechRecognizedEventArgs>(sr_SpeechRecognized);
            while (true)
            {
                Console.Read();
            }
        }
Пример #22
0
        public static SrgsDocument BuildSrgsGrammar(CultureInfo cultureInfo)
        {
            SrgsDocument document = new SrgsDocument();

            document.Culture = cultureInfo;

            // Collect all subject items and add them to the document
            subjectObject = new Subject();
            foreach (SrgsRule rule in subjectObject.RuleList)
            {
                document.Rules.Add(rule);
            }

            SrgsRuleRef subjectRef = new SrgsRuleRef(subjectObject.RootRule);

            commandObjects = new Dictionary <string, Command>();
            SrgsOneOf commandSet = new SrgsOneOf();

            SrgsItem select = new SrgsItem();

            select.Add(new SrgsItem(subjectRef));
            select.Add(new SrgsSemanticInterpretationTag("out.subject=rules.subject;"));
            commandSet.Add(select);

            #region Commands

            #region Move (1)

            // Return to formation (1)
            Command regroup = new Command("REGROUP", new string[] { "regroup", "return to formation", "fall back", "on me" }, "regroup", subjectRef);
            commandObjects.Add("REGROUP", regroup);
            commandSet.Add(regroup.Item);

            // Advance (2)
            Command advance = new Command("ADVANCE", new string[] { "advance", "move up" }, "advance", subjectRef);
            commandObjects.Add("ADVANCE", advance);
            commandSet.Add(advance.Item);

            // Stop (6)
            Command stop = new Command("STOP", new string[] { "stop", "hold position", "halt", "stay here" }, "stop", subjectRef);
            commandObjects.Add("STOP", stop);
            commandSet.Add(stop.Item);

            // Move to (Space)
            Command move = new Command("MOVE", new string[] { "move", "get over there", "move up" }, "move", subjectRef);
            commandObjects.Add("MOVE", move);
            commandSet.Add(move.Item);
            #endregion

            #region Engage (3)

            // Open fire (1)
            Command openFire = new Command("OPENFIRE", new string[] { "open fire", "fire at will", "weapons free", "go loud" }, "open fire", subjectRef);
            commandObjects.Add("OPENFIRE", openFire);
            commandSet.Add(openFire.Item);

            // Hold fire (1)
            Command holdFire = new Command("HOLDFIRE", new string[] { "hold fire", "cease fire", "go quiet" }, "hold fire", subjectRef);
            commandObjects.Add("HOLDFIRE", holdFire);
            commandSet.Add(holdFire.Item);

            // Fire (3)
            Command fire = new Command("FIRE", new string[] { "fire", "take the shot", "send it" }, "fire", subjectRef);
            commandObjects.Add("FIRE", fire);
            commandSet.Add(fire.Item);

            // Engage (4)
            Command engage = new Command("ENGAGE", new string[] { "engage", "move to engage" }, "engage", subjectRef);
            commandObjects.Add("ENGAGE", engage);
            commandSet.Add(engage.Item);

            // Engage at will (5)
            Command engageAtWill = new Command("ENGAGEATWILL", new string[] { "engage at will" }, "engage at will", subjectRef);
            commandObjects.Add("ENGAGEATWILL", engageAtWill);
            commandSet.Add(engageAtWill.Item);

            // Disengage (6)
            Command disengage = new Command("DISENGAGE", new string[] { "disengage" }, "disengage", subjectRef);
            commandObjects.Add("DISENGAGE", disengage);
            commandSet.Add(disengage.Item);

            // Suppressive fire (9)
            Command suppressiveFire = new Command("SUPRESS", new string[] { "supressive fire", "supress" }, "suppressive fire", subjectRef);
            commandObjects.Add("SUPRESS", suppressiveFire);
            commandSet.Add(suppressiveFire.Item);

            #endregion

            #region Combat Mode (7)

            // Stealth (1)
            Command stealth = new Command("STEALTH", new string[] { "stealth", "go quiet", "go silent" }, "stealth", subjectRef);
            commandObjects.Add("STEALTH", stealth);
            commandSet.Add(stealth.Item);

            // Combat (2)
            Command combat = new Command("COMBAT", new string[] { "combat", "danger" }, "combat", subjectRef);
            commandObjects.Add("COMBAT", combat);
            commandSet.Add(combat.Item);

            // Aware (3)
            Command aware = new Command("AWARE", new string[] { "aware", "alert", "stay sharp", "stay frosty", "stay alert" }, "aware", subjectRef);
            commandObjects.Add("AWARE", aware);
            commandSet.Add(aware.Item);

            // Relax (4)
            Command relax = new Command("RELAX", new string[] { "relax", "safe", "at ease" }, "relax", subjectRef);
            commandObjects.Add("RELAX", relax);
            commandSet.Add(relax.Item);

            // Stand up (6)
            Command standUp = new Command("STANDUP", new string[] { "stand up", "get up", "stand" }, "stand up", subjectRef);
            commandObjects.Add("STANDUP", standUp);
            commandSet.Add(standUp.Item);

            // Stay crouched (7)
            Command crouch = new Command("CROUCH", new string[] { "crouch", "get low", "stay low" }, "crouch", subjectRef);
            commandObjects.Add("CROUCH", crouch);
            commandSet.Add(crouch.Item);

            // Go prone (8)
            Command prone = new Command("PRONE", new string[] { "prone", "get down", "go prone", "down", "hit the dirt" }, "prone", subjectRef);
            commandObjects.Add("PRONE", prone);
            commandSet.Add(prone.Item);

            // Copy my stance (9)
            Command copyStance = new Command("COPYSTANCE", new string[] { "copy my stance", "default stance" }, "copy stance", subjectRef);
            commandObjects.Add("COPYSTANCE", copyStance);
            commandSet.Add(copyStance.Item);

            #endregion

            #region Formation (8)

            // Column (1)
            Command column = new Command("COLUMN", new string[] { "formation column", "form column" }, "column", subjectRef);
            commandObjects.Add("COLUMN", column);
            commandSet.Add(column.Item);

            // Staggered column (2)
            Command staggeredColumn = new Command("STAGGEREDCOLUMN", new string[] { "formation staggered column", "form staggered column" }, "staggered column", subjectRef);
            commandObjects.Add("STAGGEREDCOLUMN", staggeredColumn);
            commandSet.Add(staggeredColumn.Item);

            // Wedge (3)
            Command wedge = new Command("WEDGE", new string[] { "formation wedge", "form wedge" }, "wedge", subjectRef);
            commandObjects.Add("WEDGE", wedge);
            commandSet.Add(wedge.Item);

            // Echelon Left (4)
            Command echelonLeft = new Command("ECHELONLEFT", new string[] { "formation echelon left", "form echelon left" }, "echelon left", subjectRef);
            commandObjects.Add("ECHELONLEFT", echelonLeft);
            commandSet.Add(echelonLeft.Item);

            // Echelon Right (5)
            Command echelonRight = new Command("ECHELONRIGHT", new string[] { "formation echelon right", "form echelon right" }, "echelon right", subjectRef);
            commandObjects.Add("ECHELONRIGHT", echelonRight);
            commandSet.Add(echelonRight.Item);

            // Vee (6)
            Command vee = new Command("VEE", new string[] { "formation vee", "form vee" }, "vee", subjectRef);
            commandObjects.Add("VEE", vee);
            commandSet.Add(vee.Item);

            // Line (7)
            Command line = new Command("LINE", new string[] { "formation line", "form line" }, "line", subjectRef);
            commandObjects.Add("LINE", line);
            commandSet.Add(line.Item);

            // File (8)
            Command file = new Command("FILE", new string[] { "formation file", "form file" }, "file", subjectRef);
            commandObjects.Add("FILE", file);
            commandSet.Add(file.Item);

            // Diamond (9)
            Command diamond = new Command("DIAMOND", new string[] { "formation diamond", "form diamond" }, "diamond", subjectRef);
            commandObjects.Add("DIAMOND", diamond);
            commandSet.Add(diamond.Item);

            #endregion

            #endregion

            SrgsRule commands = new SrgsRule("commands");
            commands.Add(commandSet);

            document.Rules.Add(commands);
            document.Root = commands;

            return(document);
        }
Пример #23
0
        public static SrgsDocument BuildSrgsGrammar(CultureInfo cultureInfo)
        {
            SrgsDocument document = new SrgsDocument();

            document.Culture = cultureInfo;

            // make a new subject item and then add all of it's rules to the document
            subjectObject = new Subject();
            foreach (SrgsRule rule in subjectObject.RuleList)
            {
                document.Rules.Add(rule);
            }

            SrgsRuleRef subjectRef = new SrgsRuleRef(subjectObject.RootRule);

            // go through and add all of the commands
            commandObjects = new Dictionary <string, Command>();
            SrgsOneOf commandSet = new SrgsOneOf();

            // add just the subjects
            SrgsItem select = new SrgsItem();

            select.Add(new SrgsItem(subjectRef));
            select.Add(new SrgsSemanticInterpretationTag("out.subject=rules.subject;"));
            commandSet.Add(select);

            #region Commands
            #region Move (1)
            // return to formation (1)
            Command returnToFormation = new Command("FORMUP", new string[] { "return to formation", "form up", "fallback", "fall back", "regroup", "join up", "rally on me", "rally to me" }, new [] { DirectInputEmulator.KeyPress(DirectInputKeys.One), DirectInputEmulator.KeyPress(DirectInputKeys.One) }, subjectRef);
            commandObjects.Add("FORMUP", returnToFormation);
            commandSet.Add(returnToFormation.Item);

            // advance (2)
            Command advance = new Command("ADVANCE", new string[] { "advance", "move up" }, new[] { DirectInputEmulator.KeyPress(DirectInputKeys.One), DirectInputEmulator.KeyPress(DirectInputKeys.Two) }, subjectRef);
            commandObjects.Add("ADVANCE", advance);
            commandSet.Add(advance.Item);

            // stay back (3)
            Command stayBack = new Command("STAYBACK", new string[] { "stay back", "go back", "back up" }, new [] { DirectInputEmulator.KeyPress(DirectInputKeys.One), DirectInputEmulator.KeyPress(DirectInputKeys.Three) }, subjectRef);
            commandObjects.Add("STAYBACK", stayBack);
            commandSet.Add(stayBack.Item);

            // flank left (4)
            Command flankLeft = new Command("FLANKLEFT", new string[] { "flank left", "go left" }, new [] { DirectInputEmulator.KeyPress(DirectInputKeys.One), DirectInputEmulator.KeyPress(DirectInputKeys.Four) }, subjectRef);
            commandObjects.Add("FLANKLEFT", flankLeft);
            commandSet.Add(flankLeft.Item);

            // flank right (5)
            Command flankRight = new Command("FLANKRIGHT", new string[] { "flank right", "go right" }, new [] { DirectInputEmulator.KeyPress(DirectInputKeys.One), DirectInputEmulator.KeyPress(DirectInputKeys.Five) }, subjectRef);
            commandObjects.Add("FLANKRIGHT", flankRight);
            commandSet.Add(flankRight.Item);

            // stop (6)
            Command stop = new Command("STOP", new string[] { "stop", "hold position", "halt", "stay there", "stay here" }, new [] { DirectInputEmulator.KeyPress(DirectInputKeys.One), DirectInputEmulator.KeyPress(DirectInputKeys.Six) }, subjectRef);
            commandObjects.Add("STOP", stop);
            commandSet.Add(stop.Item);

            // Wait for me (7)
            Command waitForMe = new Command("WAIT", new string[] { "wait for me", "wait up", "wait" }, new [] { DirectInputEmulator.KeyPress(DirectInputKeys.One), DirectInputEmulator.KeyPress(DirectInputKeys.Seven) }, subjectRef);
            commandObjects.Add("WAIT", waitForMe);
            commandSet.Add(waitForMe.Item);

            // Find cover (8)
            Command cover = new Command("COVER", new string[] { "go for cover", "look for cover", "cover", "find cover", "get to cover", "hide" }, new [] { DirectInputEmulator.KeyPress(DirectInputKeys.One), DirectInputEmulator.KeyPress(DirectInputKeys.Eight) }, subjectRef);
            commandObjects.Add("COVER", cover);
            commandSet.Add(cover.Item);

            // Next waypoint (9)
            Command nextWaypoint = new Command("NEXTWAYPOINT", new string[] { "next waypoint", "go to the next waypoint" }, new [] { DirectInputEmulator.KeyPress(DirectInputKeys.One), DirectInputEmulator.KeyPress(DirectInputKeys.Nine) }, subjectRef);
            commandObjects.Add("NEXTWAYPOINT", nextWaypoint);
            commandSet.Add(nextWaypoint.Item);
            #endregion

            #region Target (2)
            // open menu
            Command openTargetMenu = new Command("OPENTARGET", new string[] { "show targets", "target menu", "open target menu", "targets" }, new [] { DirectInputEmulator.KeyPress(DirectInputKeys.Two) }, subjectRef);
            commandObjects.Add("OPENTARGET", openTargetMenu);
            commandSet.Add(openTargetMenu.Item);

            // cancel target (1)
            Command cancelTarget = new Command("CANCELTARGET", new string[] { "cancel target", "cancel targets", "no target" }, new [] { DirectInputEmulator.KeyPress(DirectInputKeys.Two), DirectInputEmulator.KeyPress(DirectInputKeys.One) }, subjectRef);
            commandObjects.Add("CANCELTARGET", cancelTarget);
            commandSet.Add(cancelTarget.Item);
            #endregion

            #region Engage (3)
            // open fire (1)
            Command openFire = new Command("OPENFIRE", new string[] { "open fire", "go loud", "fire at will" }, new [] { DirectInputEmulator.KeyPress(DirectInputKeys.Three), DirectInputEmulator.KeyPress(DirectInputKeys.One) }, subjectRef);
            commandObjects.Add("OPENFIRE", openFire);
            commandSet.Add(openFire.Item);

            // hold fire (2)
            Command holdFire = new Command("HOLDFIRE", new string[] { "hold fire", "go quiet", "cease fire" }, new [] { DirectInputEmulator.KeyPress(DirectInputKeys.Three), DirectInputEmulator.KeyPress(DirectInputKeys.Two) }, subjectRef);
            commandObjects.Add("HOLDFIRE", holdFire);
            commandSet.Add(holdFire.Item);

            // fire (3)
            Command fire = new Command("FIRE", new string[] { "fire", "take the shot" }, new [] { DirectInputEmulator.KeyPress(DirectInputKeys.Three), DirectInputEmulator.KeyPress(DirectInputKeys.Three) }, subjectRef);
            commandObjects.Add("FIRE", fire);
            commandSet.Add(fire.Item);

            // engage (4)
            Command engage = new Command("ENGAGE", new string[] { "engage", "move to engage" }, new [] { DirectInputEmulator.KeyPress(DirectInputKeys.Three), DirectInputEmulator.KeyPress(DirectInputKeys.Four) }, subjectRef);
            commandObjects.Add("ENGAGE", engage);
            commandSet.Add(engage.Item);

            // engage at will (5)
            Command enageAtWill = new Command("ENGAGEATWILL", new string[] { "engage at will" }, new [] { DirectInputEmulator.KeyPress(DirectInputKeys.Three), DirectInputEmulator.KeyPress(DirectInputKeys.Five) }, subjectRef);
            commandObjects.Add("ENGAGEATWILL", enageAtWill);
            commandSet.Add(enageAtWill.Item);

            // disengage (6)
            Command disengage = new Command("DISENGAGE", new string[] { "disengage" }, new [] { DirectInputEmulator.KeyPress(DirectInputKeys.Three), DirectInputEmulator.KeyPress(DirectInputKeys.Six) }, subjectRef);
            commandObjects.Add("DISENGAGE", disengage);
            commandSet.Add(disengage.Item);

            // scan horizon (7)
            Command scanHorizon = new Command("SCANHORIZON", new string[] { "scan horizon", "scan the horizon" }, new [] { DirectInputEmulator.KeyPress(DirectInputKeys.Three), DirectInputEmulator.KeyPress(DirectInputKeys.Seven) }, subjectRef);
            commandObjects.Add("SCANHORIZON", scanHorizon);
            commandSet.Add(scanHorizon.Item);

            // watch direction (8)
            // team direct object
            DirectObject direction = new DirectObject("directionDO");
            direction.Add(new string[] { "north" }, "NORTH", new [] { DirectInputEmulator.KeyPress(DirectInputKeys.One) });
            direction.Add(new string[] { "north east" }, "NORTHEAST", new [] { DirectInputEmulator.KeyPress(DirectInputKeys.Two) });
            direction.Add(new string[] { "east" }, "EAST", new [] { DirectInputEmulator.KeyPress(DirectInputKeys.Three) });
            direction.Add(new string[] { "south east" }, "SOUTHEAST", new [] { DirectInputEmulator.KeyPress(DirectInputKeys.Four) });
            direction.Add(new string[] { "south" }, "SOUTH", new [] { DirectInputEmulator.KeyPress(DirectInputKeys.Five) });
            direction.Add(new string[] { "south west" }, "SOUTHWEST", new [] { DirectInputEmulator.KeyPress(DirectInputKeys.Six) });
            direction.Add(new string[] { "west" }, "WEST", new [] { DirectInputEmulator.KeyPress(DirectInputKeys.Seven) });
            direction.Add(new string[] { "north west" }, "NORTHWEST", new [] { DirectInputEmulator.KeyPress(DirectInputKeys.Eight) });

            foreach (SrgsRule rule in direction.RuleList)
            {
                document.Rules.Add(rule);
            }

            Command watch = new Command("WATCH", new string[] { "watch", "watch the" }, new [] { DirectInputEmulator.KeyPress(DirectInputKeys.Three), DirectInputEmulator.KeyPress(DirectInputKeys.Eight) }, subjectRef, direction);
            commandObjects.Add("WATCH", watch);
            commandSet.Add(watch.Item);

            // suppressive fire (9)
            Command suppresiveFire = new Command("SUPRESS", new string[] { "suppresive fire", "suppress" }, new [] { DirectInputEmulator.KeyPress(DirectInputKeys.Three), DirectInputEmulator.KeyPress(DirectInputKeys.Nine) }, subjectRef);
            commandObjects.Add("SUPRESS", suppresiveFire);
            commandSet.Add(suppresiveFire.Item);
            #endregion

            #region Mount (4)
            // open mount menu
            Command openMountMenu = new Command("OPENMOUNT", new string[] { "show mount menu", "open mount menu", "show vehicles", "mount menu", "get in vehicle" }, new [] { DirectInputEmulator.KeyPress(DirectInputKeys.Four) }, subjectRef);
            commandObjects.Add("OPENMOUNT", openMountMenu);
            commandSet.Add(openMountMenu.Item);

            // dismount (1)
            Command dismount = new Command("DISMOUNT", new string[] { "dismount", "get out" }, new [] { DirectInputEmulator.KeyPress(DirectInputKeys.Four), DirectInputEmulator.KeyPress(DirectInputKeys.One) }, subjectRef);
            commandObjects.Add("DISMOUNT", dismount);
            commandSet.Add(dismount.Item);
            #endregion

            #region Action (6)
            // open menu
            Command openActionMenu = new Command("OPENACTION", new string[] { "show actions", "action menu", "perform action", "do action", "open action menu", "actions" }, new [] { DirectInputEmulator.KeyPress(DirectInputKeys.Six) }, subjectRef);
            commandObjects.Add("OPENACTION", openActionMenu);
            commandSet.Add(openActionMenu.Item);
            #endregion

            #region Combat Mode (7)
            // stealth (1)
            Command stealth = new Command("STEALTH", new string[] { "stealth", "stealthy", "stealth mode" }, new [] { DirectInputEmulator.KeyPress(DirectInputKeys.Seven), DirectInputEmulator.KeyPress(DirectInputKeys.One) }, subjectRef);
            commandObjects.Add("STEALTH", stealth);
            commandSet.Add(stealth.Item);

            // combat (2)
            Command combat = new Command("COMBAT", new string[] { "combat", "danger", "combat mode" }, new [] { DirectInputEmulator.KeyPress(DirectInputKeys.Seven), DirectInputEmulator.KeyPress(DirectInputKeys.Two) }, subjectRef);
            commandObjects.Add("COMBAT", combat);
            commandSet.Add(combat.Item);

            // aware (3)
            Command aware = new Command("AWARE", new string[] { "aware", "alert", "aware mode", "stay sharp", "stay frosty", "stay alert" }, new [] { DirectInputEmulator.KeyPress(DirectInputKeys.Seven), DirectInputEmulator.KeyPress(DirectInputKeys.Three) }, subjectRef);
            commandObjects.Add("AWARE", aware);
            commandSet.Add(aware.Item);

            // relax (4)
            Command relax = new Command("RELAX", new string[] { "relax", "relaxed mode", "safe" }, new [] { DirectInputEmulator.KeyPress(DirectInputKeys.Seven), DirectInputEmulator.KeyPress(DirectInputKeys.Four) }, subjectRef);
            commandObjects.Add("RELAX", relax);
            commandSet.Add(relax.Item);

            // stand up (6)
            Command standUp = new Command("STANDUP", new string[] { "stand up", "get up", "stand" }, new [] { DirectInputEmulator.KeyPress(DirectInputKeys.Seven), DirectInputEmulator.KeyPress(DirectInputKeys.Six) }, subjectRef);
            commandObjects.Add("STANDUP", standUp);
            commandSet.Add(standUp.Item);

            // stay crouched (7)
            Command stayCrouched = new Command("CROUCH", new string[] { "get low", "crouch", "stay crouched", "stay low" }, new [] { DirectInputEmulator.KeyPress(DirectInputKeys.Seven), DirectInputEmulator.KeyPress(DirectInputKeys.Seven) }, subjectRef);
            commandObjects.Add("CROUCH", stayCrouched);
            commandSet.Add(stayCrouched.Item);

            // go prone (8)
            Command goProne = new Command("PRONE", new string[] { "go prone", "get down", "prone", "hit the dirt", "down" }, new [] { DirectInputEmulator.KeyPress(DirectInputKeys.Seven), DirectInputEmulator.KeyPress(DirectInputKeys.Eight) }, subjectRef);
            commandObjects.Add("PRONE", goProne);
            commandSet.Add(goProne.Item);

            // copy my stance (9)
            Command copyMyStance = new Command("COPYMYSTANCE", new string[] { "copy my stance", "default stance" }, new [] { DirectInputEmulator.KeyPress(DirectInputKeys.Seven), DirectInputEmulator.KeyPress(DirectInputKeys.Nine) }, subjectRef);
            commandObjects.Add("COPYMYSTANCE", copyMyStance);
            commandSet.Add(copyMyStance.Item);
            #endregion

            #region Formation (8)
            // column (1)
            Command column = new Command("COLUMN", new string[] { "formation column", "form column" }, new [] { DirectInputEmulator.KeyPress(DirectInputKeys.Eight), DirectInputEmulator.KeyPress(DirectInputKeys.One) }, subjectRef);
            commandObjects.Add("COLUMN", column);
            commandSet.Add(column.Item);

            // staggered column (2)
            Command staggeredColumn = new Command("STAGGEREDCOLUMN", new string[] { "formation staggered column", "form staggered column" }, new [] { DirectInputEmulator.KeyPress(DirectInputKeys.Eight), DirectInputEmulator.KeyPress(DirectInputKeys.Two) }, subjectRef);
            commandObjects.Add("STAGGEREDCOLUMN", staggeredColumn);
            commandSet.Add(staggeredColumn.Item);

            // wedge (3)
            Command wedge = new Command("WEDGE", new string[] { "formation wedge", "form wedge" }, new [] { DirectInputEmulator.KeyPress(DirectInputKeys.Eight), DirectInputEmulator.KeyPress(DirectInputKeys.Three) }, subjectRef);
            commandObjects.Add("WEDGE", wedge);
            commandSet.Add(wedge.Item);

            // echelon left (4)
            Command echelonLeft = new Command("ECHELONLEFT", new string[] { "formation echelon left", "form echelon left" }, new [] { DirectInputEmulator.KeyPress(DirectInputKeys.Eight), DirectInputEmulator.KeyPress(DirectInputKeys.Four) }, subjectRef);
            commandObjects.Add("ECHELONLEFT", echelonLeft);
            commandSet.Add(echelonLeft.Item);

            // echelon right (5)
            Command echeloneRight = new Command("ECHELONRIGHT", new string[] { "formation echelon right", "form echelon right" }, new [] { DirectInputEmulator.KeyPress(DirectInputKeys.Eight), DirectInputEmulator.KeyPress(DirectInputKeys.Five) }, subjectRef);
            commandObjects.Add("ECHELONRIGHT", echeloneRight);
            commandSet.Add(echeloneRight.Item);

            // vee (6)
            Command vee = new Command("VEE", new string[] { "formation vee", "form vee" }, new [] { DirectInputEmulator.KeyPress(DirectInputKeys.Eight), DirectInputEmulator.KeyPress(DirectInputKeys.Six) }, subjectRef);
            commandObjects.Add("VEE", vee);
            commandSet.Add(vee.Item);

            // line (7)
            Command line = new Command("LINE", new string[] { "formation line", "form line" }, new [] { DirectInputEmulator.KeyPress(DirectInputKeys.Eight), DirectInputEmulator.KeyPress(DirectInputKeys.Seven) }, subjectRef);
            commandObjects.Add("LINE", line);
            commandSet.Add(line.Item);

            // file (8)
            Command file = new Command("FILE", new string[] { "formation file", "form file" }, new [] { DirectInputEmulator.KeyPress(DirectInputKeys.Eight), DirectInputEmulator.KeyPress(DirectInputKeys.Eight) }, subjectRef);
            commandObjects.Add("FILE", file);
            commandSet.Add(file.Item);

            // diamond (9)
            Command diamond = new Command("DIAMOND", new string[] { "formation diamond", "form diamond" }, new [] { DirectInputEmulator.KeyPress(DirectInputKeys.Eight), DirectInputEmulator.KeyPress(DirectInputKeys.Nine) }, subjectRef);
            commandObjects.Add("DIAMOND", diamond);
            commandSet.Add(diamond.Item);
            #endregion

            #region Assign Team (9)
            // team direct object
            DirectObject team = new DirectObject("teamDO");
            team.Add(new string[] { "team red", "red" }, "RED", new [] { DirectInputEmulator.KeyPress(DirectInputKeys.One) });
            team.Add(new string[] { "team green", "green" }, "GREEN", new [] { DirectInputEmulator.KeyPress(DirectInputKeys.Two) });
            team.Add(new string[] { "team blue", "blue" }, "BLUE", new [] { DirectInputEmulator.KeyPress(DirectInputKeys.Three) });
            team.Add(new string[] { "team yellow", "yellow" }, "YELLOW", new [] { DirectInputEmulator.KeyPress(DirectInputKeys.Four) });
            team.Add(new string[] { "team white", "white" }, "WHITE", new [] { DirectInputEmulator.KeyPress(DirectInputKeys.Five) });

            foreach (SrgsRule rule in team.RuleList)
            {
                document.Rules.Add(rule);
            }

            Command assignTeam = new Command("ASSIGN", new string[] { "assign", "assign to", "add to", "switch to" }, new [] { DirectInputEmulator.KeyPress(DirectInputKeys.Nine) }, subjectRef, team);
            commandObjects.Add("ASSIGN", assignTeam);
            commandSet.Add(assignTeam.Item);
            #endregion

            // not implemented
            #region WW_AiMenu
            #region Infantry Commands (1)
            // heal up (1)

            // rearm (2)

            // inventory (3)

            // fire on my lead (4)

            // garrison building (5)

            // clear building (6)

            // follow target (7)
            #endregion

            #region WayPoints (4)
            // set waypoints (1)

            // add waypoints (2)

            // move waypoints (3)

            // delete waypoints (4)

            // wait on waypoint (5)

            // cycle waypoint (6)
            #endregion
            #endregion
            #endregion

            // set the root rule to
            SrgsRule commands = new SrgsRule("commands");
            commands.Add(commandSet);

            document.Rules.Add(commands);
            document.Root = commands;

            return(document);
        }
Пример #24
0
 public Command(string semantic, string[] alternates, uint[] keyList, SrgsRuleRef subjectRef)
 {
     GenerateRuleList(semantic, alternates, subjectRef);
     GenerateKeyLookup(semantic, keyList);
 }