Partilhar via


Grammar Example: Solitaire

  Microsoft Speech Technologies Homepage

Grammar rules define sentence contents and phrase elements. Each grammar and grammar element determines the speech recognition (SR) engine's ability to effectively construct phrase elements. Phrases and subexpressions are commonly represented by a separate rule and combined into larger phrases and sentences with higher level rules. For more information, see the Grammars Overview section.

The card game, solitaire, uses semantic objects such as cards, suits, and ranks, and semantic actions, such as "move SomeCard to AnotherCard," and "new game." The following example illustrates how to implement a grammar for a game of solitaire, which supports the previously mentioned semantic objects and actions. The example also specifies the exact voice command phrases (in U.S. English) that must be spoken in order to play the game.

<!-- The grammar tag surrounds the entire CFG description.
       The language of the grammar is specified as English-American ('en-US') -->
<grammar root="toplevel" version="1.0" xmlns="http://www.w3.org/2001/06/grammar"
 xml:lang="en-US" tag-format="semantics-ms/1.0"> 

   <!-- Define a top-level rule to reference all of the rules
        that need to be active, as soon as speech
        is activated in the application -->   
   <!-- $toplevel.Newgame : integer (in the case of NewGame)
        $toplevel.Card : $Card (in the case of PlayCard)
        $toplevel.FromCard : $Card (in the case of MoveCard)
        $toplevel.ToCard : $Card (in the case of MoveCard) -->
   <rule id="toplevel" scope="public">
       <one-of>
           <item> <ruleref uri="#NewGame"/> <tag> $.NewGame = $$ </tag> </item>
           <item> <ruleref uri="#PlayCard"/> <tag> $ = $$ </tag> </item>
           <item> <ruleref uri="#MoveCard"/> <tag> $ = $$ </tag> </item>
       </one-of>
   </rule>

   <!-- $NewGame._value : string ( "NewGame" ) -->
   <rule id="NewGame" scope="public">
       <example> new game </example>
       <example> new game please </example>
       new game
       <tag> $._value = "NewGame" </tag>
       <!-- Make the last word, please, optional,
              to make the command phrasing more flexible -->
       <item repeat="0-1"> please </item>
   </rule>

   <!-- Define 'PlayCard' as a public rule, so that
          it can be used to create other solitaire or 
          card game grammars-->
   <!-- $PlayCard.Card = $Card -->
   <rule id="PlayCard" scope="public">
       <example> please play the red queen </example>
       <example> play the ace </example>
        <item repeat="0-1"> please </item>
        play the
        <!-- Allow for extraneous garbage words
              from the user. The user could say
              "play the little ace of spades" without
              breaking the voice command -->
        <item repeat="0-1">
            <ruleref special="GARBAGE"/>
        </item>
        <ruleref uri="#Card"/>
        <tag> $.Card = $$ </tag>
        <item repeat="0-1"> please </item>
   </rule>

   <!-- Define another public rule to be included in the top-level voice
           commands for moving one card to another location.
        Note that phrase structure allows for two
           types of move-commands by making the ToCard
           section optional. The grammar supports
           both 'move FromCard to ToCard' and
           simply 'move FromCard'. -->

   <!-- $MoveCard.FromCard : Card
        $MoveCard.ToCard : Card (optional) -->
   <rule id="MoveCard">
        <example> please move the red queen </example>
        <example> put the ace </example>
        <example> move the queen of clubs to the black four please </example>
        <item repeat="0-1"> please </item>
        <one-of>
            <item> move </item>
            <item> put </item>
        </one-of>
        the
        <ruleref uri="#Card"/>
        <!-- The semantic object returned from the Card rule will be stored
             under the slot FromCard. By
             using semantic properties, the application
             can abstract away the exact phrase text
             and build application logic based on
             the intended action (that is, Action=
             moveFromCard=(Rank=Ace, Suit=Hearts) -->
        <tag> $.FromCard = $$ </tag>
        <item repeat="0-1">
            <one-of>
                <item> on </item>
                <item> to </item>
            </one-of>
            the
            <!-- The semantic object returned from the Card rule this time will
                 be stored under the slot ToCard. -->
            <ruleref uri="#Card"/>
            <tag> $.ToCard = $$ </tag> 
        </item>
        <item repeat="0-1"> please </item>
   </rule>

   <!-- Create a reusable Card grammar that contains
           the structure of a card's descriptor (for example,
           "red ace", "ace of hearts", or "heart"). 
        The application can decode the card by analyzing the 
           semantic object from the Rank, Suit, or the Color
           slots.  -->
   <!-- $Card.Color : $Color (optional)
        $Card.Suit : $Suit (optional)
        $Card.Rank : $Rank (optional) -->
   <rule id="Card">
       <example> red queen </example>
       <example> jack of clubs </example>
       <example> ace </example>
       <example> spade </example>
       <one-of>
           <item>
               <!-- color and rank form -->
               <ruleref uri="#Color"/>
               <tag> $.Color = $$ </tag>
               <ruleref uri="#Rank"/>
               <tag> $.Rank = $$ </tag>
           </item>
           <item>
               <!-- rank and optional suit form -->
               <ruleref uri="#Rank"/>
               <tag> $.Rank = $$ </tag>
               <item repeat="0-1">
                   of
                   <ruleref uri="#Suits"/>
                   <tag> $.Suit = $$ </tag>
               </item>
           </item>
           <item>
               <!-- suit only form -->
               <ruleref uri="#Suit"/>
               <tag> $.Suit = $$ </tag>
           </item>
       </one-of>
   </rule>
   
   <!-- Create a reusable grammar component, called
           'Color' that represents the color information.
        The application can use the semantic object
           called 'Color', which is a string.
        $Color._value : string ("Red", "Black")
    -->
   <rule id="Color">
       <example> red </example>
       <example> black </example>
       <one-of>
           <item> red <tag> $._value = "Red" </tag> </item>
           <item> black <tag> $._value = "Black" </tag> </item>
       </one-of>
   </rule>

   <!-- Create a reusable grammar component, called
           'Suit' that represents the suit information.
        The application can use the semantic object
           called 'Suit', which is a string.
        $Suit._value : string ("Club", "Heart", "Diamond", "Spade")
    -->
   <rule id="Suit">
       <example> spade </example>
       <example> club </example>
       <one-of>
           <item> club <tag> $._value = "Club" </tag> </item>
           <item> heart <tag> $._value = "Heart" </tag> </item>
           <item> diamond <tag> $._value = "Diamond" </tag> </item>
           <item> spade <tag> $._value = "Spade" </tag> </item>
       </one-of>
   </rule>

   <!-- Create a reusable grammar component, called
           'Suits' that represents the suit information.
           This rule accepts the plural form of the Suits.
        $Suits._value : string ("Club", "Heart", "Diamond", "Spade")
    -->
   <rule id="Suits">
       <example> spades </example>
       <example> clubs  </example>
       <one-of>
           <item> clubs  <tag> $._value = "Club" </tag> </item>
           <item> hearts <tag> $._value = "Heart" </tag> </item>
           <item> diamonds <tag> $._value = "Diamond" </tag> </item>
           <item> spades <tag> $._value = "Spade" </tag> </item>
       </one-of>
   </rule>

   <!-- Create a reusable grammar component, called
           'Rank' that represents the numeric rank
           of the various cards. Note that each card
           has an associated value.
        The application can use the semantic object
           called 'Rank' (an integer value between 1 to 13)
           to abstract program logic from the exact phrasing of 
           the speech, and use only the numeric rank values. 
           Note that the words 'king' and 'emperor' both refer 
           to the value 13. The grammar author can change
           or update the text without breaking the
           application.
        $Rank._value : integer ([1,13])
    -->
   <rule id="Rank">
      <example> ace </example> 
      <example> five </example> 
      <example> king </example> 
      <example> jack </example> 
      <one-of>
         <item> ace <tag> $._value = 1 </tag> </item>
         <item> two <tag> $._value = 2 </tag> </item>
         <item> three <tag> $._value = 3 </tag> </item>
         <item> four <tag> $._value = 4 </tag> </item>
         <item> five <tag> $._value = 5 </tag> </item>
         <item> six <tag> $._value = 6 </tag> </item>
         <item> seven <tag> $._value = 7 </tag> </item>
         <item> eight <tag> $._value = 8 </tag> </item>
         <item> nine <tag> $._value = 9 </tag> </item>
         <item> ten <tag> $._value = 10 </tag> </item>
         <item> jack <tag> $._value = 11 </tag> </item>
         <item> queen <tag> $._value = 12 </tag> </item>
         <item> king <tag> $._value = 13 </tag> </item>
         <item> lady <tag> $._value = 12 </tag> </item>
         <item> emperor <tag> $._value = 13 </tag> </item>
      </one-of>
   </rule>
</grammar>