home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 January / usenetsourcesnewsgroupsinfomagicjanuary1994.iso / sources / games / volume15 / dinkum / part05 / parse.c < prev   
C/C++ Source or Header  |  1993-01-27  |  14KB  |  711 lines
  1. #define PARSE
  2. #include "dink_sym.h"
  3. #include "dink_glb.h"
  4. #include <string.h>
  5.  
  6. void parse()
  7. /*********************************************************/
  8. /*                                                       */
  9. /*      --- English Language Parsing Subroutine ---      */
  10. /*                                                       */
  11. /*  This subroutine parses a sentence of up to nineteen  */
  12. /*  words and decodes the words into integers and passes */
  13. /*  a twenty element vector back to the calling          */
  14. /*  program.  The digit 0, implies an unused word.  The  */
  15. /*  digit -1 (V_LINE_END), indicates end of sentence.    */
  16. /*                                                       */
  17. /*      Program by Gary A. Allen, Jr.   5 March 1990     */
  18. /*        (c) Copywrite 1990 by Gary A. Allen, Jr.       */
  19. /*                                                       */
  20. /*********************************************************/
  21. {
  22. #ifdef __TURBOC__ 
  23. char getche(void) ;
  24. void purge(int, int*) ;
  25. #endif
  26.  
  27. register int i, j ;
  28. int m, n, j_point, jacc, i_ws, sw_adverb, sw_purge, j_purge, sw_punct ;
  29. int sw_movement, sw_adverb_fnd ;
  30. int j_old = 0 ; /* this is to keep Lint happy */
  31. /* a sentence can have 19 words of 15 letters */ 
  32. char words[20][15], word[15] ;
  33. char letter ;
  34.  
  35. /* flush the "sent vector" */
  36. for (i=0; i<=19; i++) sent[i]=0 ;
  37.  
  38. /* flush the tag vector */
  39. for (i=0; i<= tag_max; i++) tag[i] = FALSE ;
  40.  
  41. /* Parse and load in the words */
  42. input:
  43. sw_punct = FALSE ;
  44. for (i=0; i <= 18; i++) {
  45.     for (j=0; j <= 14; j++) {
  46. #ifndef __TURBOC__
  47.         letter = getchar() ;    
  48. #endif
  49.  
  50. #ifdef __TURBOC__
  51.         letter = getche() ;    
  52. #endif
  53.  
  54.         switch (letter) {
  55.             case '\n':
  56.             case 13 :
  57.                 if ((i == 0) && (j == 0)) goto input ;
  58.                 words[i][j] = '\0' ;  
  59.                 goto decode; 
  60.  
  61.             case 8:
  62.                 if (sw_punct) {
  63.                     if (--i < 0) i = 0 ;
  64.                     j = j_old ;
  65.                     sw_punct = FALSE ;
  66.                 }
  67.                 else if (--j < 0) j = 0 ;
  68.                 --j ;
  69.                 continue ;
  70.  
  71.             case '\"':
  72.             case ' ':
  73.             case ',':
  74.             case '.':
  75.             case ';':
  76.             case ':':
  77.             case '?':
  78.             case '!':
  79.             case '&':
  80.             case '{':
  81.             case '}':
  82.             case '[':
  83.             case ']':
  84.             case ')':
  85.             case '(':
  86.             case '\'':
  87.             case '`':
  88.             case '\t':
  89.                 words[i][j] = '\0' ;  
  90.                 sw_punct = TRUE ;
  91.                 j_old = j ;
  92.                 break;
  93.  
  94.             default:
  95.                 words[i][j] = letter ;
  96.                 sw_punct = FALSE ;
  97.                 continue ;
  98.         }
  99.         break ;
  100.     }
  101.     if (j > 14) {
  102. printf("\nYou're saying nonsense! Type the sentence again. \n");
  103.         break ;
  104.     }
  105.     if (j == 0) i-- ;
  106. }
  107. if (i > 18) 
  108. printf ("\nYour sentence is too long. Type something shorter! \n") ;
  109.  
  110. #ifndef __TURBOC__
  111. /* Purge the input buffer */
  112.     for (;;) if ('\n' == getchar()) break ;
  113. goto input;
  114. /* decode the words from the known vocabulary */
  115. decode:
  116. #endif
  117.  
  118. #ifdef __TURBOC__
  119. goto input;
  120. /* decode the words from the known vocabulary */
  121. decode:
  122. printf("\n") ;
  123. #endif
  124.  
  125. m=i ;
  126. jacc=0;
  127. for (i=0; i<=m; i++) {
  128.     for (j=0; j<=14; j++) {
  129.         word[j] = words[i][j] ; 
  130.     }
  131.     for (j=0; j<=letmax; j++) {
  132.         n = strcmp (word,vocab[j]);
  133.         if (n == 0) {
  134.             if ((j>9)&&(j<20)) j -= 10;
  135.             sent[jacc++]=j+1 ;
  136.             break; 
  137.         }
  138.     }
  139. }
  140.  
  141. if (jacc == 0) {
  142.     printf ("Nothing you said was understandable! Try again. \n");
  143.     goto input; 
  144. }
  145.  
  146. /* mark last word */
  147. sent[jacc] = V_LINE_END ;
  148.  
  149. /* Check to see if this is a simple move command */
  150. if (sent[0] <= 10) {
  151.     tag[V_MOVE] = TRUE ;
  152.     tag[V_DIRECTION] = TRUE ;
  153.     verb = sent[0] ;
  154.     return ; 
  155. }
  156.  
  157. /* adjective and "in/out" preposition scan */
  158. sw_purge = FALSE ;
  159. for (j = 0; j <= jacc-1; j++) {
  160.  
  161.     /* check for adjectives*/
  162.     for (i = 0; i <= adj_max; i++) {
  163.         if (sent[j] == adjective[i][Aj_adj]) {
  164.  
  165.         /* does a noun have to be ignored ? */
  166.         if (adjective[i][Aj_adj_cmd] == F_ignore) {
  167.         if (adjective[i][Aj_trig_noun] != sent[j+1]) break ;
  168.         }
  169.  
  170.         /* does a noun have to be replaced? */
  171.         if (adjective[i][Aj_adj_cmd] == F_replace) {
  172.             if (adjective[i][Aj_trig_noun] == sent[j+1]) {
  173.             sent[j+1] = adjective[i][Aj_act_noun] ;
  174.             }
  175.         }
  176.         sw_purge = TRUE ;
  177.         j_purge = j ;
  178.         }
  179.     }
  180. }
  181.  
  182. /* purge processed adjective from sentence */
  183. if (sw_purge) purge(j_purge, &jacc) ;
  184.  
  185. /* Verb grammer check */
  186. /* see if the sentence is of a command sentax */
  187. for (i = 0; i <= verb_max; i++) {
  188.     if (sent[0] == verb_table[i]) goto synonym ;
  189. }
  190.  
  191. /* the first word is --not-- a verb, so one must be swapped in */
  192. if (jacc != 1) for (j = 1; j <= jacc-1; j++) {
  193.     /* Check to see if the word is a move command */
  194.     if (sent[j] <= 10) {
  195.         tag[V_MOVE] = TRUE ;
  196.         i_ws = sent[0] ;
  197.         sent[0] = sent[j] ;
  198.         sent[j] = i_ws ;
  199.         goto synonym ;
  200.     }
  201.     /* if not a move command then check the verb table */
  202.     for (i = 0; i <= verb_max; i++) {
  203.         if (sent[j] == verb_table[i]) {
  204.             i_ws = sent[0] ;
  205.             sent[0] = sent[j] ;
  206.             sent[j] = i_ws ;
  207.             goto synonym ;
  208.         }
  209.     }
  210. }
  211.  
  212. /* Check to see if this is a "question" sentence */
  213. for (i = 0; i <= quest_max; i++) {
  214.     if (sent[0] == quest[i]) {
  215.         /* shift the sentence over and load in "question" */ 
  216.         for (j = jacc; j >= 0; j--) sent[j+1] = sent[j] ;
  217.         sent[0] = V_QUESTION ;
  218.         tag[V_QUESTION] = TRUE ; 
  219.         if (++jacc == 2) {
  220.         /* Sentence is a one word command */
  221.             tag[V_VERB_ONLY] = TRUE ;
  222.             tag[sent[1]] = TRUE ;
  223.             verb = V_QUESTION ;
  224.             return ;
  225.         }
  226.         goto synonym ;
  227.     } 
  228. }
  229.  
  230. /* Verb error routine */
  231. printf ("If there was a verb in that sentence, I didn't understand ") ;
  232. printf ("it.\n") ;
  233. goto input ;
  234.  
  235. synonym:
  236. /* prescan for verb connected movement commands */
  237. switch(sent[0]) { 
  238. case V_go:
  239. case V_move:
  240. case V_walk:
  241. case V_run:
  242. case V_jump:
  243. case V_bop:
  244. case V_hop:
  245. case V_stroll:
  246. case V_saunter:
  247. case V_swagger:
  248.     sw_movement = TRUE ;
  249.     break ;
  250. default:
  251.     sw_movement = FALSE ;
  252. }
  253.  
  254. /* adverb scan, sent[0] is the verb */
  255. sw_adverb = FALSE ;
  256. sw_adverb_fnd = FALSE ;
  257. for (i = 0; i <= adv_max; i++) {
  258.     for (j = 1; j <= jacc-1; j++) {
  259.         /* see if this is an adverb */
  260.         if (sent[j] == adverb[i][Av_adv]) {
  261.             j_point = j ;
  262.             sw_adverb = TRUE ;
  263.  
  264.             /* does the sentence have the companion verb? */
  265.             if (adverb[i][Av_verb_old] == sent[0]) {
  266.                 sent[0] = adverb[i][Av_verb_new] ;
  267.                 sw_adverb = FALSE ;
  268.                 sw_adverb_fnd = TRUE ;
  269.  
  270.             /* purge processed adverb from sentence */
  271.                 purge(j, &jacc) ;
  272.             }
  273.         }
  274.     }
  275. }
  276.  
  277. /* purge unprocessed adverb from sentence */
  278. if (sw_adverb && (!sw_movement)) purge(j_point, &jacc) ;
  279.  
  280. /* scan the sentence for the movement direction */
  281. if ((!sw_adverb_fnd) && sw_movement) {
  282.     for (j = 0; j <= jacc-1; j++) {
  283.         if (sent[j] <= 10) {
  284.             tag[V_MOVE] = TRUE ;
  285.             tag[V_DIRECTION] = TRUE ;
  286.             verb = sent[j] ;
  287.             return ;
  288.         }
  289.         if (sent[j] == V_LINE_END) break ;
  290.     }
  291.     printf("Where to?  In what direction?\n") ;
  292.     goto input ;
  293. } 
  294.  
  295. tag[sent[0]] = TRUE ;  /* activate the tag for the verb */
  296.  
  297. if (jacc == 1) {
  298. /* Sentence is a one word command */
  299.     tag[V_VERB_ONLY] = TRUE ;
  300.     verb = sent[0] ;
  301.     if (sent[0] <= 4) return ; /* first 5 elements are reserved */
  302.     return ;
  303. }
  304.  
  305. /* Load the "tag" matrix for detected words and synonyms */
  306. for (j=1; j <= 19; j++) {
  307.     if (sent[j] == V_LINE_END) break ;
  308.     if (sent[j] <= 10) tag[V_DIRECTION] = TRUE ;
  309.     if (sent[j] <= 4) continue ; /* first 5 elements are reserved */
  310.     tag[sent[j]] = TRUE ;  /* activate an element for each word */
  311.  
  312.     /* Deal with synonym nouns */
  313.     switch(sent[j]) {
  314.  
  315.     case V_automatic:
  316.     case V_AUTO:
  317.         tag[V_auto] = TRUE ;
  318.         continue ;
  319.  
  320.     case V_bar:
  321.         tag[V_gold] = TRUE ;
  322.         continue ;
  323.  
  324.     case V_beer:
  325.     case V_fourex:
  326.     case V_Fourex:
  327.         tag[V_can] = TRUE ;
  328.         continue ;
  329.  
  330.     case V_cockroaches:
  331.         tag[V_PLURAL] = TRUE ;
  332.         tag[V_cockroach] = TRUE ;
  333.         continue ;
  334.  
  335.     case V_diamond:
  336.         tag[V_ring] = TRUE ;
  337.         continue ;
  338.  
  339.     case V_doormat:
  340.         tag[V_mat] = TRUE ;
  341.         continue ;
  342.  
  343.     case V_drop:
  344.         tag[V_bear] = TRUE ;
  345.         continue ;
  346.  
  347.     case V_everything:
  348.         tag[V_all] = TRUE ;
  349.         continue ;
  350.  
  351.     case V_lager:
  352.         tag[V_bottle] = TRUE ;
  353.         continue ;
  354.  
  355.     case V_fuse:
  356.         tag[V_cap] = TRUE ;
  357.         continue ;
  358.  
  359.     case V_gleeps:
  360.         tag[V_PLURAL] = TRUE ;
  361.         tag[V_gleep] = TRUE ;
  362.         continue ;
  363.  
  364.     case V_hoop:
  365.         tag[V_snake] = TRUE ;
  366.         continue ;
  367.  
  368.     case V_M16:
  369.     case V_m16:
  370.     case V_gun:
  371.         tag[V_rifle] = TRUE ;
  372.         continue ;
  373.  
  374.     case V_kangaroos:
  375.         tag[V_PLURAL] = TRUE ;
  376.         tag[V_kangaroo] = TRUE ;
  377.         continue ;
  378.  
  379.     case V_magazine:
  380.     case V_ammo:
  381.         tag[V_clip] = TRUE ;
  382.         continue ;
  383.  
  384.     case V_mail:
  385.     case V_envelope:
  386.         tag[V_letter] = TRUE ;
  387.         continue ;
  388.  
  389.     case V_matches:
  390.         tag[V_PLURAL] = TRUE ;
  391.         tag[V_match] = TRUE ;
  392.         continue ;
  393.  
  394.     case V_Ned:
  395.     case V_kelly:
  396.     case V_Kelly:
  397.         tag[V_ned] = TRUE ;
  398.         continue ;
  399.  
  400.     case V_off_q:
  401.         tag[V_off] = TRUE ;
  402.         continue ;
  403.  
  404.     case V_on_q:
  405.         tag[V_on] = TRUE ;
  406.         continue ;
  407.  
  408.     case V_plan:
  409.         tag[V_map] = TRUE ;
  410.         continue ;
  411.  
  412.     case V_painting:
  413.         tag[V_picture] = TRUE ;
  414.         continue ;
  415.  
  416.     case V_doors:
  417.         tag[V_PLURAL] = TRUE ;
  418.         tag[V_door] = TRUE ;
  419.         continue ;
  420.  
  421.     case V_pills:
  422.     case V_packet:
  423.         tag[V_PLURAL] = TRUE ;
  424.     case V_atropine:
  425.         tag[V_pill] = TRUE ;
  426.         continue ;
  427.  
  428.     case V_safety:
  429.     case V_SAFE:
  430.         tag[V_safe] = TRUE ;
  431.         continue ;
  432.  
  433.     case V_silver:
  434.         tag[V_coin] = TRUE ;
  435.         continue ;
  436.  
  437.     case V_spinifexes:
  438.         tag[V_PLURAL] = TRUE ;
  439.         tag[V_spinifex] = TRUE ;
  440.         continue ;
  441.  
  442.     case V_stick:
  443.         tag[V_dynamite] = TRUE ;
  444.         continue ;
  445.  
  446.     case V_switch:
  447.         tag[V_button] = TRUE ;
  448.         continue ;
  449.  
  450.     case V_treasure:
  451.         tag[V_all] = TRUE ;
  452.         continue ;
  453.  
  454.     case V_I:
  455.         tag[V_single] = TRUE ;
  456.         continue ;
  457.  
  458.     case V_III:
  459.         tag[V_triple] = TRUE ;
  460.         continue ;
  461.  
  462.     case V_zero:
  463.         tag[V_0] = TRUE ;
  464.         continue ;
  465.  
  466.     case V_forty_nine:
  467.         tag[V_49] = TRUE ;
  468.         continue ;
  469.  
  470.     case V_sixty_seven:
  471.         tag[V_67] = TRUE ;
  472.         continue ;
  473.  
  474.     case V_eighty_two:
  475.         tag[V_82] = TRUE ;
  476.         continue ;
  477.  
  478.     default:
  479.         continue ;
  480.     }
  481. } /* end of sentence tag word scan */
  482. verb = sent[0] ;
  483. return ;
  484.  
  485. } /* --- end of "parse" subroutine --- */
  486.  
  487. void purge(k_start, k_finish)
  488. /***********************************/
  489. /*                                 */
  490. /*   Sentence Purging Subroutine   */
  491. /*                                 */
  492. /* Version: Mk 1.0  3 March 1990   */
  493. /*                                 */
  494. /***********************************/
  495.  
  496. int k_start, *k_finish ;
  497. {
  498. register int k ;
  499. int k_end ;
  500.  
  501. k_end = *k_finish ;
  502. for (k = k_start; k <= k_end-1; k++) sent[k] = sent[k+1] ;
  503. *k_finish = --k_end ;
  504. } /* --- end of "purge" subroutine --- */
  505.  
  506. void filler()
  507. /***********************************/
  508. /*                                 */
  509. /*        Looker Subroutine        */
  510. /*                                 */
  511. /* Version: Mk 1.0  18 August 1989 */
  512. /*                                 */
  513. /***********************************/
  514. {
  515.  
  516. if (tag[V_VERB_ONLY]) {
  517.     printf("Fill what?\n") ;
  518.     return ;
  519. }
  520. if (tag[V_can]) {
  521.     if (object[O_can][J_loc] != B_have) 
  522. printf("You don't have the Fourex can in your possession!\n") ;
  523. else printf("I can't do it!  There's a hole in the can's bottom.\n") ;
  524.     return ;
  525. }
  526. if (tag[V_bottle]) {
  527.     if (object[O_bottle][J_loc] != B_have) 
  528. printf("You don't have the bottle in your possession!\n") ;
  529. else printf("I can't do it!  The bottle has a crack in it's bottom.\n");
  530.     return ;
  531. }
  532. printf("I can't fill that!\n") ;
  533. } /* --- end of the "filler" subroutine --- */
  534.  
  535. void looker(n)
  536. /***********************************/
  537. /*                                 */
  538. /*        Looker Subroutine        */
  539. /*                                 */
  540. /* Version: Mk 1.0  18 August 1989 */
  541. /*                                 */
  542. /***********************************/
  543. int n ;
  544. {
  545. #ifdef __TURBOC__
  546. void long_descp(int), describe(int), objlooker(int), gleeper(int) ;
  547. void actor(int), rdtxt(int) ;
  548. #endif
  549.  
  550. int m ;
  551.  
  552. /* an isolated "look" means to just look at the room */
  553. if (tag[V_VERB_ONLY]) { 
  554.     /* goto long description test*/
  555.     if ((room[n][M_rm_type] == T_was_long)||(n == R_lift_inside))
  556.        long_descp(n);
  557.     else describe (n) ;
  558.     objlooker(n) ; /* Check if there are objects in the room */
  559.     gleeper(n) ;   /* check for gleeps and update the gleep count */
  560.     /* describe unmovable action objects and status */
  561.     if (room[n][M_rm_type] == T_action_obj) actor(n) ;
  562.     return ;
  563. }
  564.  
  565. /* Gleep tank */
  566. if (tag[V_tank]) {
  567.     if (n == R_gleep_tank) {
  568. printf("You look inside the gleep tank and see a blue fluid which\n") ;
  569. printf("smells of chlorine") ;
  570.         if (gleep_score == 0) {
  571. printf(".\n") ;
  572.             return ;
  573.         }
  574.         if (gleep_score == 1) {
  575. printf(" and a single gleep submerged in the fluid.\n") ;
  576.             return ;
  577.         }
  578. printf(" and %d gleeps submerged in the fluid.\n",
  579.         gleep_score) ;
  580.         return ;
  581.     }
  582.     else {
  583.         printf("There is no gleep tank here!\n") ;
  584.         return ;
  585.     }
  586. }
  587.  
  588. /* wall safe */
  589. if (tag[V_safe]) {
  590.     if ((n == R_office_mang)&&
  591.         (room[R_office_mang][M_rm_status] >= S_revealed)) {
  592.         m = O_safe ;
  593.         rdtxt(m);
  594.     }
  595.     else printf("I see no safe here for me to describe.\n");
  596.     return ;
  597. }
  598.  
  599. for (;;) {
  600.     /* map from the manager's office */
  601.     if (tag[V_map]) {
  602.         m = O_map_frag ;
  603.         break ;
  604.     }
  605.  
  606.     /* Fourex can */
  607.     if (tag[V_can]) {
  608.         m = O_can ;
  609.         break ;
  610.     }
  611.  
  612.     /* Atropine pills */
  613.     if (tag[V_pill]) {
  614.         m = O_pills ;
  615.         break ;
  616.     }
  617.  
  618.     /* Qadaffi's letter bomb */
  619.     if (tag[V_letter]) {
  620.         m = O_letter ;
  621.         break ;
  622.     }
  623.  
  624.     /* paper from the safe */
  625.     if (tag[V_paper]) {
  626.          m = O_paper ;
  627.         break ;
  628.     }
  629.  
  630.     /* ammo clip */            
  631.     if (tag[V_clip]) {
  632.         m = O_clip ;
  633.         break ;
  634.     }
  635.  
  636.     /* orange clip */
  637.     if (tag[V_org_clip]) {
  638.         m = O_org_clip ;
  639.         break ;
  640.     }
  641.  
  642.     /* rifle */
  643.     if (tag[V_rifle]) {
  644.         m = O_rifle ;
  645.         break ;
  646.     }
  647.  
  648.     /* Semtex detector */
  649.     if (tag[V_detector]) {
  650.         m = O_detector ;
  651.         break ;
  652.     }
  653.  
  654.     /* Deal with unreadable objects */
  655.     printf("There is nothing more that I can describe about it.\n");
  656.     return ;
  657. } /* end of infinite for block */
  658.  
  659. if (object[m][J_loc] == B_have) rdtxt(m);
  660. else 
  661. printf("I can examine an object only if it is in my possession.\n");
  662.  
  663. } /* --- end of the "looker" subroutine --- */
  664.  
  665. void pass()
  666. /***********************************/
  667. /*                                 */
  668. /*        Password Subroutine      */
  669. /*                                 */
  670. /* Version: Mk 1.0  29 July 1989   */
  671. /*                                 */
  672. /***********************************/
  673. {
  674.  
  675. #ifdef __TURBOC__
  676. void exit(int);
  677. char getch(void) ;
  678. #endif
  679.  
  680. register int i ;
  681. char chr ;
  682. static char *passwd = "2Xngootx7Ysd4Du9" ;
  683.  
  684. /* Request password */
  685. printf("Enter password:  ") ;
  686.  
  687. #ifndef __TURBOC__
  688. for (i = 2; i <= 7; i++) {
  689.     chr = getchar() ;
  690.     if (chr+i-1 != passwd[i]) exit(0) ;
  691. }    
  692. if (getchar() != '\n') exit(0) ;
  693. printf(".\n") ;  /* indicate that the password was accepted */
  694. #endif
  695.  
  696. #ifdef __TURBOC__
  697. for (i = 2; i <= 7; i++) {
  698.     chr = getch() ;
  699.     if (chr+i-1 != passwd[i]) { 
  700.         for (;;) if (getch() == 3) break ;
  701.         printf("\r                    \n") ;
  702.         exit(0) ;
  703.     }
  704. }
  705. printf("\r.                     \n") ;
  706. #endif
  707.  
  708. sw_wizard = TRUE ; /* toggle wizard switch */
  709.  
  710. } /* --- end of the "pass" subroutine */
  711.