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