The JSpeech Grammar Format (JSGF) is a platform-independent, vendor-independent textual representation of grammars for use in speech recognition. Grammars are used by speech recognizers to determine what the recognizer should listen for, and so describe the utterances a user may say. JSGF adopts the style and conventions of the JavaTM Programming Language in addition to use of traditional grammar notations.

Read:
W3C Documentation[www.w3.org]

Since the people over at CMUSphinx didn't include the actual grammar used for their graph, the graph loses a lot of educational value. I'll fix that for you:


Here's the grammar:


As you can see, there are quite a lot of possible sentences you can speak using quite little typing. This is especially useful if you want your users to be able to speak freely and not follow strict commands like "please delete the file" as they can now talk more naturally and say for example:

• "Could you please delete the file?"
  
• "Could you delete the file?"
  
• "Please delete the file?"
  
• "Delete the file?"
  
• ...

Have you ever tried commandeering your team? It's tidious! All that scrolling and clicking.. jesus. Good luck writing 100's of commands for each possible task. 100's? Yes. Arma has color coded teams, explicit unit control by number, explicit assignments,...

• "Everyone follow me"
  
• "Unit one follow me"
  
• "Unit two follow me"
  
• "Unit three follow me"
  
• ...
  
• "Team blue follow me"
  
• "Team red follwo me"
  
• ...

You catch the drift right? Each of those would have to be implemented as explicit command. 1 command per Team Color & action.

You'd have 10's of commands to just make a single colored team do all the actions like "follow, fall back, advance, ..."



Using this grammar, you basically have all the options to assign units to teams, commandeer units, teams or everyone, let them do whatever you want and have just 5 defined commands.

• "Red team is team Blue" to re-assign the units of red to the blue team.
  
• Combine mupltiple units/teams and issue them a command at the same time like "team red and blue fall back, team green advance, team yellow watch north-east."

It goes without saying that this greatly enhances your efficiency on the battlefield and saves you a lot of writing in the end.

Well, by now you must have asked yourself how on earth you're going to process all those possibilities in your script and execute the appropirate action.. Well.. brace yourself.


JSGF Supports tagging and VOTC will give those tags to your script in addition to the string representation of the sentence/command/words the user spoke. Parsing commands that are valid in your JSGF file without tags is almost impossible or far too expensive to compute at one point. All the if/else's, ordering and sometimes even heuristics would make your script huge, slow and painful to read/write.

Tagging helps a lot. I told you to tag your grammar in the beginning.

For JSGF commands like this one


the Tag "Command2" is enough. There are just 10's of possible words the user could have said, so you can go straight ahead and string match the spoken word with your List of "Operations" and execute the associated keystrokes.


I'm assuming a Dictionary<string, Action> Dictionary, where the key corresponds each value in your <operation> jsgf rule and the value a method/lambda that executes the keystrokes and gives TTS feedback.



Now let's look at


This one is too complex to process using onle "Command1" as tag, but we don't have any other tags assigned in the jsgf file. That's basically because when I wrote that grammar, I had almost no idea how to use JSGF and was happy it was valid JSGF. Don't. Be. Me.

Let's analyze that command so we can understand it better:

Remember, things in []'s are optional. We will discard [unit] and [and] as irrelevant and ignore it completely. That makes the braces around "[unit] <number> [and]" irrelevant aswell.

We have one or more units according to
and one operation according to


Which means, we could have commands like

• "one, two, three, advance"
  
• "one advance"

Let's tag <number> and <operation>. We will using {Number} and {Operation} as tags and put them at the end of each line associated BUT before the semikolon (;)



Now we'll get more tags back.

Which means commands like

• "one, two, three, advance"
  
• "one advance"

will also be fully represented by tags like

• "Number Number Number Operation Command1"
  
• "Number Operation Command1"

All you have to do now is split the sentence in numbers and operation and execute each keystroke.

In this example, it'd be as easy as doing


Additionally, you could remove the words we deemed useless like "unit" and "and" and skip the contains key check.

Also, a Dictionary<string, Dictionary<string, Action>> might work better in complex scripts where you could then do things like

Dict[Tag][Word].Invoke()