home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 January / usenetsourcesnewsgroupsinfomagicjanuary1994.iso / sources / games / volume15 / dinkum2 / part05 / opener.c < prev   
C/C++ Source or Header  |  1993-01-27  |  27KB  |  952 lines
  1. #define OPNR
  2. #include "dink_sym.h"
  3. #include "dink_glb.h"
  4.  
  5. void dialer(n)
  6. /*****************************/
  7. /*      "dial" command"      */
  8. /*     Version:  Mk 1.1      */
  9. /*      29 October 1989      */
  10. /*****************************/
  11. int n ;
  12. {
  13.  
  14. /* deal with the question of "What is the combination?" */
  15. if (tag[V_what]) {
  16. printf("I really don't know.  You might try looking around for a\n") ;
  17. printf("series of numbers. Sometimes that can be a clue to the\n") ;
  18. printf("actual combination.\n") ;
  19.     return ;
  20. }
  21.  
  22. /* See if the combination was dialed in the right place */
  23. if ((n == R_office_mang)&&
  24.     (room[R_office_mang][M_rm_status] >= S_revealed)) {
  25.     if (tag[V_0] && tag[V_49] && tag[V_67] && tag[V_82]) {
  26.         printf ("Click!! \n");
  27.         room[R_office_mang][M_rm_status] = S_dialed ;
  28.         return ; 
  29.     }
  30. printf ("You turned the dial but nothing happened.  I think you \n");   
  31. printf ("dialed the wrong thing. \n");
  32.     return ; 
  33. }
  34. printf ("How am I supposed to dial that? \n");
  35. } /* --- end of the "dialer" subroutine --- */
  36.  
  37.  
  38. void inventer()
  39. /*****************************/
  40. /*   "inventory" command     */
  41. /*     Version:  Mk 1.0      */
  42. /*       11 March 1989       */
  43. /*****************************/
  44. {
  45. #if (PROTOTYPE)
  46. void objector(int) ;
  47. #endif
  48.  
  49. register int i;
  50. int i_ws, j_ws ;
  51.  
  52. i_ws = 0 ;
  53. j_ws = 0 ;
  54. for (i = 0; i <= objcnt; i++) if (object[i][J_loc] == B_have)  {
  55.     ++j_ws;
  56.     i_ws = i ;
  57.     } ;
  58. if ((j_ws == 0)&&(gleep_count == 0)) {
  59.     printf("You've got NOTHING!! \n") ;
  60.     return ;
  61. }
  62. if (j_ws >= 1) {
  63.     if (j_ws == 1) {
  64.         printf("You are carrying ") ;
  65.         objector(i_ws);
  66.         printf ("\n") ;
  67.     }
  68.     else {
  69.         printf ("You are carrying the following: \n");
  70.         for (i = 0; i <= objcnt; i++) {
  71.             if (object[i][J_loc] == B_have) {
  72.                 printf ("        ") ;
  73.                 objector(i);
  74.                 printf ("\n") ;
  75.             }
  76.         }
  77.     }
  78. }
  79. if (gleep_count > 0) {
  80.     if (gleep_count == 1) {
  81.         printf("You have one gleep.\n") ;
  82.         return ;
  83.     }
  84.     printf("You are carrying %d gleeps. \n",gleep_count) ;
  85. }
  86.  
  87. } /* --- end of the "inventor" subroutine --- */
  88.  
  89. void drinker()
  90. /*****************************/
  91. /*     "drink" command       */
  92. /*     Version:  Mk 1.0      */
  93. /*       11 March 1989       */
  94. /*****************************/
  95. {
  96. #if (PROTOTYPE)
  97. void no_booze(void) ;
  98. #endif
  99.  
  100. if (tag[V_can]) {
  101.     if (object[O_can][J_loc] == B_have) {
  102.         printf("The XXXX keeps on coming on ? \n") ;
  103. printf("I think not, for there is no Fourex left for me to drink!\n") ;
  104.     }
  105.     else no_booze() ;
  106.     return ;
  107. }
  108.  
  109. if (tag[V_bottle]) {
  110.     if (object[O_bottle][J_loc] == B_have) {
  111. printf("Some greedy larrikin has drunk up all of the Black Swan! \n") ;
  112.     printf("Bad on Him! There is none left for me! \n") ;
  113.     return ;
  114.     }
  115.     no_booze() ;
  116.     return ;
  117. }
  118.  
  119. if (tag[V_water]) {
  120.     printf("There is no water here that I am willing to drink.\n") ;
  121.     return ;
  122. }
  123.     
  124. printf ("What exactly do you want me to drink? \n");
  125. return; 
  126.  
  127. } /* --- end of the "drinker" subroutine --- */
  128.  
  129. void no_booze()
  130. /*****************************/
  131. /*     Version:  Mk 1.0      */
  132. /*     7 December 1992       */
  133. /*****************************/
  134. {
  135. printf ("You don't have it in your possession to drink!\n");
  136. return ;
  137. } /* --- end of the "no_booze" subroutine --- */
  138.  
  139.  
  140. void reader(n)
  141. /*****************************/
  142. /*      "read" command       */
  143. /*     Version:  Mk 1.2      */
  144. /*      23 December 1992     */
  145. /*****************************/
  146.  
  147. int n ;
  148. {
  149. int k ;
  150.  
  151. #if (PROTOTYPE)
  152. void rdtxt(int) ;
  153. #endif
  154.  
  155. /* reject an isolated "read" command */
  156. if (tag[V_VERB_ONLY]) { 
  157.         printf ("What exactly do you want me to read? \n");
  158.         return;
  159. }
  160.  
  161. for (;;) {
  162.     /* map from the manager's office */
  163.     if (tag[V_map]) {
  164.         k = O_map_frag ;
  165.         break;
  166.     }
  167.  
  168.     /* Qadaffi's letter */
  169.     if (tag[V_letter]) {
  170.         k = O_letter ;
  171.         break ;
  172.     }
  173.  
  174.     /* paper from the safe */
  175.     if (tag[V_paper]) {
  176.         k = O_paper ;
  177.         break;
  178.     }
  179.  
  180.     /* Message on wall */
  181.     if ((tag[V_message] || tag[V_wall]) && (n == R_no_treasure)) {
  182.         k = O_message ;
  183.         rdtxt(k) ;
  184.         return ;
  185.     }
  186.  
  187.     /* Deal with unreadable objects */
  188.     printf("There is no way in which I can read that. \n");
  189.         return ;
  190. } /* end of the infinite for loop */
  191.  
  192. if (object[k][J_loc] == B_have) rdtxt(k) ;
  193. else printf ("I can't read it because it isn't in my possession. \n");
  194. }         /* --- end of the subroutine "reader" --- */
  195.  
  196. void unlocker(n)
  197. /*****************************/
  198. /*     "unlock" command      */
  199. /*      Version: Mk 1.1      */
  200. /*      16 September 1989    */
  201. /*****************************/
  202. int n ;
  203. {
  204.  
  205. if (tag[V_VERB_ONLY]) {
  206.     printf ("What do you want me to unlock? \n");
  207.     return; 
  208. }
  209.  
  210. if (room[n][M_rm_type] == T_action_obj) {
  211.     switch (n) {
  212.  
  213.     /* Managers office */
  214.     case R_office_mang:
  215.         if (tag[V_safe]) {
  216. printf("This is a combination type safe (no key hole).  You must\n");
  217. printf("dial a combination in order to open this safe. \n");
  218.         }
  219.         else 
  220. printf("You're wasting your time.  You can't unlock that! \n");
  221.         return;
  222.  
  223.     /* office entrance */
  224.     case R_office_entr:
  225.     if (tag[V_door]) {
  226.         if (room[R_office_entr][M_rm_status] == S_open) {
  227.             printf("The door is already open! \n");
  228.             return;
  229.         }
  230.         if (room[R_office_entr][M_rm_status] == S_kicked) {
  231.             printf("The door has been kicked in! \n");
  232.             return;
  233.         }
  234.         if (room[R_office_entr][M_rm_status] == S_unlocked) {
  235. printf("The door is already unlocked.  However it is still closed! \n");
  236.             return;
  237.         }
  238.         /* The door has to still be unlocked */
  239.         if (tag[V_key]) {
  240.         if (object[O_key][J_loc] != B_have) {
  241. printf("You don't have the key to this door in your possession! \n");
  242.         }
  243.         else {
  244.             printf("You turn the key in the lock and ") ;
  245.             printf("hear a satisfying \"click\".\n");
  246.             room[R_office_entr][M_rm_status] = S_unlocked ;
  247.         }
  248.         }
  249.         else printf ("With what shall I unlock the door? \n");
  250.         return; 
  251.     }
  252.  
  253.     default:
  254. printf("I don't think that is the sort of thing one unlocks.\n") ;
  255.     }  /* end of "unlock" room scan switch */
  256. } /* end of "unmovable action device" block */
  257. else printf("There is nothing here that can be unlocked! \n");
  258. return ;
  259. }  /* --- end of the "unlocker" subroutine --- */
  260.  
  261. void closer(n)
  262. /*****************************/
  263. /*     "close" command       */
  264. /*     Version:  Mk 1.0      */
  265. /*     12 November 1988      */
  266. /*****************************/
  267. int n ;
  268. {
  269.  
  270. /* scan "close" sentence */
  271. if (room[n][M_rm_type] != T_action_obj) {
  272. printf("There is nothing here that can be closed! \n");
  273.     return; 
  274. }
  275.  
  276. if (tag[V_VERB_ONLY]) {
  277.     printf ("What exactly do you want me to close? \n");
  278.     return; 
  279. }
  280.  
  281. switch (n) {
  282.     /* office door */
  283.     case R_office_entr:
  284.         if (!tag[V_door]) break ;
  285.         if (room[R_office_entr][M_rm_status] == S_kicked) {
  286. printf("The door has been kicked in!  It'll never be closed again.\n");
  287.             return;
  288.         }
  289.         if (room[R_office_entr][M_rm_status] == S_open) {
  290.         printf("The office door closes with a slam. \n");
  291.             room[R_office_entr][2] = R_wall ;
  292.             room[R_office_entr][M_rm_status] = S_closed ;
  293.             return ;
  294.         }
  295.         else printf("The office door is already closed! \n");
  296.         return ;
  297.  
  298.     /* managers office */
  299.     case R_office_mang:
  300.     if ((!tag[V_picture])&&(!tag[V_safe])) break;
  301.     if (tag[V_safe]) {
  302.         if (room[R_office_mang][M_rm_status] < S_dialed) 
  303.         printf("The safe is already closed. \n");
  304.         else {
  305.     printf("The safe door closes and locks with a \"click\". \n");
  306.             room[R_office_mang][M_rm_status] = S_revealed ;
  307.         }
  308.     }
  309.     if (tag[V_picture]) {
  310.         if (room[R_office_mang][M_rm_status] == S_closed) 
  311.         printf("The platypus picture is already closed. \n");
  312.         else  {
  313. printf("The picture swings flush against the wall, hiding the safe.\n");
  314.             room[R_office_mang][M_rm_status] = S_closed ;
  315.         }
  316.     }
  317.     return ;
  318.  
  319. } /* end of the "close" switch */
  320. printf ("I really don't see how one would close that? \n");
  321. return; 
  322. } /* --- end of the "closer" subroutine --- */
  323.  
  324. void opener(n)
  325. /*****************************/
  326. /*      "open" command       */
  327. /*     Version:  Mk 2.1      */
  328. /*     25 April 1990         */
  329. /*****************************/
  330. int n ;
  331. {
  332. register int i ;
  333.  
  334. #if (PROTOTYPE)
  335. void boom(void), ender(int), objector(int) ;
  336. #endif
  337.  
  338. /* deal with a terse command */
  339. if (tag[V_VERB_ONLY]) {
  340.     printf ("What exactly do you want me to open? \n");
  341.     return;
  342. }
  343.  
  344. if (tag[V_can]) {
  345.     if (object[O_can][J_loc] == B_have) 
  346. printf("Some bugger has already drunk it up. The stubee is empty!\n");
  347.     else printf("You don't have a can to open! \n") ;
  348.     return; 
  349. }
  350.  
  351. if (tag[V_letter]) {
  352.     if (object[O_letter][J_loc] == B_have) {
  353.         boom() ; /* cause an explosion */
  354. printf("It's not polite to read other people's mail!!  As you lay\n") ;
  355. printf("bleeding on the floor with your hands and arms blown away,\n") ;
  356. printf("you realize that envelope actually contained a letter bomb!\n");
  357. printf("(A trick widely used by terrorists in the 1970s).  However\n");
  358. printf("the knowledge does you little good since your spirit soon\n");
  359. printf("departs this mortal coil.\n");
  360.         ender(F_died) ;
  361.     }
  362.     else printf("You don't have a letter to open!\n") ;
  363.     return ;
  364. }
  365.  
  366. if (tag[V_bottle]) {
  367.     if (object[O_bottle][J_loc] == B_have)
  368. printf("Some bugger has already drunk it up. The bottle is Empty! \n");
  369.     else printf("You don't have a bottle to open! \n") ;
  370.     return; 
  371. }
  372.  
  373. if (tag[V_umbrella]) {
  374.     if (object[O_umbrella][J_loc] == B_have) {
  375. printf("You open the umbrella but find it's full of holes and\n");
  376. printf("its clasp is broken.  As soon as you release it, the\n");
  377. printf("umbrella snaps shut.\n") ;
  378.     }
  379.     else printf("You don't have an umbrella to open! \n") ;
  380.     return; 
  381. }
  382.  
  383. /* Now check to see if the location is consistent with the command */
  384. if (room[n][M_rm_type] != T_action_obj) { 
  385.     printf ("I don't understand what you want me to open. \n") ;
  386.     return ;
  387. }
  388.  
  389. switch (n) {
  390.     /* office entrance (door) */
  391.     case R_office_entr:
  392.         if (tag[V_door]) {
  393.         switch (room[R_office_entr][M_rm_status]) {
  394.             case S_kicked:
  395. printf("The door has been kicked in!  You don't need to open it.\n");
  396.                 return;
  397.         
  398.             case S_open:
  399.                 printf("The door is already open! \n");
  400.                 return ;
  401.         
  402.             case S_unlocked:
  403. printf("As you push open the office door, the rusty hinges creak \n");
  404. printf("from long disuse.  Darkness and stale air seem to exude \n");
  405. printf("from the vacant office.  The way is free for you to enter. \n");
  406.                 room[R_office_entr][2] = R_office_hall ;
  407.             room[R_office_entr][M_rm_status] = S_open ;
  408.                 return ;
  409.         
  410.             case S_closed:
  411. printf("The office door is locked tight.");
  412. printf("  You need to unlock it with a key. \n");
  413.                 return ;
  414.         } /* end of room status switch */
  415.         } /* end of the door "if" block */
  416.         break ;
  417.  
  418.     /* managers office */
  419.     case R_office_mang:
  420.         if ((!tag[V_picture])&&(!tag[V_safe])) {
  421. printf("I don't understand how I would open that.\n") ;
  422.             return ;
  423.         }
  424.  
  425.         if (tag[V_picture]) {
  426.         switch (room[R_office_mang][M_rm_status]) {
  427.         case S_closed:
  428. printf("You swing open the platypus picture revealing a large wall \n");
  429. printf("safe with a combination dial. \n");
  430.             room[R_office_mang][M_rm_status] = S_revealed ;
  431.             break ;
  432.         default:
  433. printf("The picture is already swung out.  The problem is to open \n");
  434. printf("the safe!!  Hint:  Dial in a combination. \n");
  435.             return ;
  436.         }
  437.         } /* end of the picture "if" block */
  438.  
  439.         if (tag[V_safe]) {
  440.         switch (room[R_office_mang][M_rm_status]) {
  441.         case S_closed:
  442. printf("I can see no safe in this office for me to open.  Perhaps\n");
  443. printf("there is a safe hidden in this office somewhere.\n");
  444.             return ;
  445.  
  446.         case S_revealed:
  447. printf("The safe is locked.  You must first dial the combination\n");
  448. printf("in order to open it.  See if you can find the combination. \n");
  449.             return ;
  450.         
  451.         case S_dialed:
  452.     printf("The safe door swings open smoothly and easily. \n");
  453.             room[R_office_mang][M_rm_status] = S_open ;
  454.             sw_active = TRUE ;
  455.             for (i=0; i <= objcnt; i++) 
  456.             if (object[i][J_loc] == B_in_safe) {
  457. printf ("Inside the safe, you see the following: \n");
  458.                 for (i=0; i <= objcnt; i++) {
  459.                 if (object[i][J_loc] == B_in_safe) {
  460.                     printf ("        ") ;
  461.                     objector(i);
  462.                     printf ("\n") ;
  463.                 }
  464.                 }                
  465.                 return ;
  466.             }
  467.         printf("---The safe is empty.--- \n");
  468.             return ;
  469.  
  470.         case S_open:
  471.             printf("The safe is already open! \n");
  472.             return ;
  473.         } /* end of the "safe" status switch */
  474.         } /* end of the safe "if" block */
  475.         return ; /* this return statement must remain */
  476.  
  477.     /* Lift door(s) */
  478.     case R_lift_entr:
  479.         if (tag[V_door]||tag[V_lift]) {
  480. printf("It is not exactly clear how I would open these doors.\n") ;
  481. printf("However I see a push button next to the lift doors.\n") ;
  482. printf("Perhaps if I pressed the button something would happen.\n") ;
  483.         }
  484.         else printf("I'm confused about what I should open.\n");
  485.         return ;
  486.         
  487. } /* end of the "open" room switch */
  488. printf ("I see nothing here that I can open. \n") ;
  489. } /* --- end of the "opener" subroutine --- */
  490.  
  491. void boom()
  492. {
  493. printf("\n\n");
  494. printf("BBBBBB      OOOOO        OOOOO      MM        MM      !!!\n");
  495. printf("B    BB   OO     OO    OO     OO    M M      M M      !!!\n");
  496. printf("B    BB   OO     OO    OO     OO    M  M    M  M      !!!\n");
  497. printf("BBBBBB    OO     OO    OO     OO    M   M  M   M      !!!\n");
  498. printf("B    BB   OO     OO    OO     OO    M    MM    M      !!!\n");
  499. printf("B    BB   OO     OO    OO     OO    M          M\n");
  500. printf("BBBBBB      OOOOO        OOOOO      M          M      !!!\n\n");
  501. } /* --- end of the "boom" subroutine --- */
  502.  
  503. void gleeper(n) 
  504. /********************************************/
  505. /*                                          */
  506. /*           Gleeper Subroutine             */
  507. /*                                          */
  508. /*     Software by Gary A. Allen, Jr.       */
  509. /*           Version: Mk 1.00               */
  510. /* (c) Copyright 1989 by Gary A. Allen, Jr. */
  511. /*                                          */
  512. /********************************************/
  513. int n ;
  514. {
  515. register int i ;
  516. int count ;
  517. static int sw_glp_st = FALSE, cnt_down = 0 ;
  518.  
  519. /* Gleep display routine */
  520. count = room[n][M_gleep] ;
  521.  
  522. if (((object[O_torch][J_loc] == B_have)&&object[O_torch][J_property])|| 
  523.     (n < 186)||(n > 202)) { 
  524.     if (count != 0) {
  525.         sw_glp_st = TRUE ; /*  gleeps can now multiply */
  526.         if (count != 1) 
  527.                printf("There are %d gleeps here. \n",count) ;
  528.         else printf("There is a gleep here. \n") ;
  529.         return ;
  530.     }
  531. }
  532.  
  533. /* Gleep reproduction routine */
  534. if (sw_glp_st == TRUE) {
  535.     if (++cnt_down > 5) {
  536.         cnt_down = 0 ;
  537.         for (i = 0; i <= 9; i++) {
  538.             if (room[gleep_spot[i]][M_gleep] == 0) continue;
  539.             if (room[gleep_spot[i]][M_gleep] > 10000) 
  540.                 ++room[gleep_spot[i]][M_gleep] ;
  541.             else room[gleep_spot[i]][M_gleep] <<= 1 ;
  542.         }
  543.     }
  544. }
  545. } /* --- end of "gleeper" subroutine --- */
  546.  
  547. void clip_in(ammo_flag)
  548. /********************************************/
  549. /*                                          */
  550. /*            Clip_In Subroutine            */
  551. /*                                          */
  552. /*     Software by Gary A. Allen, Jr.       */
  553. /*           Version: Mk 2.00               */
  554. /* (c) Copyright 1990 by Gary A. Allen, Jr. */
  555. /*                                          */
  556. /********************************************/
  557.  
  558. int ammo_flag ;
  559. {
  560. /* ammo clip insertion routine */
  561. if (object[O_rifle][J_loc] != B_have) {
  562. printf("Galah!!  You don't have a rifle to put an ammo clip into.\n");
  563.     return ;
  564. }
  565. if (clip_flag != F_no_clip) {
  566. printf("There is already an ammo clip in the rifle. \n") ;
  567.     return ;
  568. }
  569. if (((object[O_clip][J_loc] != B_have)&&(ammo_flag == F_normal_clip))||
  570. ((object[O_org_clip][J_loc] != B_have)&&(ammo_flag == F_org_clip))) {
  571. printf("You don't possess an ammo clip to put into the rifle.\n");
  572.     return ;
  573. }
  574. /* actually load the clip into the rifle */
  575. object[O_rifle][J_type] = Z_alias ;
  576. carry_count-- ;
  577. carry_weight -= object[O_clip][J_weight]  ;
  578. if (ammo_flag == F_normal_clip) {
  579.     object[O_clip][J_loc] = B_unmade ;
  580.     clip_flag = F_normal_clip ;
  581.     object[O_rifle][J_property]  = object[O_clip][J_property] ;
  582. }
  583. else {
  584.     object[O_org_clip][J_loc] = B_unmade ;
  585.     clip_flag = F_org_clip ;
  586.     object[O_rifle][J_property] = object[O_org_clip][J_property] ;
  587. }
  588. printf("The ammunition clip slides into the rifle with a \"click\".\n");
  589. printf("You have %d bullets in the clip \n",
  590.             object[O_rifle][J_property]) ;
  591. if (object[O_rifle][J_property] > 0) 
  592.     printf("You cycle the M16's bolt once to chamber a round.\n");
  593. return ;
  594. } /* --- end of the "clip_in" subroutine --- */
  595.  
  596. void clip_out(n)
  597. /********************************************/
  598. /*                                          */
  599. /*           Clip_Out Subroutine            */
  600. /*                                          */
  601. /*     Software by Gary A. Allen, Jr.       */
  602. /*           Version: Mk 1.00               */
  603. /* (c) Copyright 1989 by Gary A. Allen, Jr. */
  604. /*                                          */
  605. /********************************************/
  606. int n ;
  607. {
  608. int ammo_flag ; 
  609.  
  610. /* remove clip from rifle */
  611. if (object[O_rifle][J_loc] != B_have) {
  612.     printf("You Bloody Galah!  ") ;
  613.     printf("You don't have a rifle in your possession!\n");
  614. return ;
  615. }
  616. if (clip_flag == F_no_clip) {
  617.     printf("There is no clip in the rifle. \n") ;
  618. return ;
  619. }
  620. /* eject the clip from the rifle */
  621. object[O_rifle][J_type] = Z_normal ;
  622. if (clip_flag == F_normal_clip) {
  623.     object[O_clip][J_loc] = n ;
  624.     ammo_flag = F_normal_clip ;
  625. }
  626. else {
  627.     object[O_org_clip][J_loc] = n ;
  628.     ammo_flag = F_org_clip ;
  629. }
  630. ++room[n][M_obj_cnt] ;
  631. clip_flag = F_no_clip ;
  632. printf("You press the \"eject\" button on the rifle and the ") ;
  633. printf("magazine falls to the ground.\n") ;
  634. if (object[O_rifle][J_property] > 0) {
  635. printf("You then cycle the M16's bolt once to clear the chamber. ");
  636. printf("The unfired round\n") ;
  637. printf("is ejected from the breech and rolls out of sight. \n") ;
  638.     if (ammo_flag == F_normal_clip) 
  639.         object[O_clip][J_property] = 
  640.             --object[O_rifle][J_property] ;
  641.         else object[O_org_clip][J_property] = 
  642.                 --object[O_rifle][J_property] ;
  643.     object[O_rifle][J_property] = 0 ;
  644. }
  645. return ;
  646. } /* --- end of the "clip_out" subroutine --- */
  647.  
  648. void igniter(n)
  649. /********************************************/
  650. /*                                          */
  651. /*           Igniter Subroutine             */
  652. /*                                          */
  653. /*     Software by Gary A. Allen, Jr.       */
  654. /*           Version: Mk 1.00               */
  655. /* (c) Copyright 1989 by Gary A. Allen, Jr. */
  656. /*                                          */
  657. /********************************************/
  658.  
  659. int n ;
  660. {
  661. #if (PROTOTYPE)
  662. void switcher(int) ;
  663. long time(int) ;
  664. #endif
  665.  
  666. /* reject single verb command */
  667. if (tag[V_VERB_ONLY]) {
  668.     printf("What exactly do you want me to set alight?\n") ;
  669.     return ;
  670. }
  671.  
  672. /* deal with 'light torch' command */
  673. if (tag[V_torch]) {
  674.     switcher(n) ;
  675.     return ;
  676. }
  677.  
  678. /* see if the player has or requested matches */
  679. if (!tag[V_match]) {
  680. printf("What am I to light it with?\n") ;
  681. printf("(I am not prepared to rub two sticks together.)\n") ;
  682.     return ;
  683. }
  684. if (object[O_matches][J_loc] != B_have) {
  685. printf("I have no matches!\n") ;
  686.     return ;
  687. }
  688. else {
  689. /* reject spurious "ignite" command */
  690.     if ((!tag[V_cap])&&(!tag[V_dynamite])&&
  691.         (sent[2] != V_LINE_END)) {
  692. printf("It would be a fire hazard to set that alight.\n");
  693.         return ;
  694.     }
  695.  
  696. /* deal with spurious "light dynamite with match" */
  697. if (tag[V_dynamite]&&(object[O_dynamite][J_loc] != B_have)) {
  698. printf("You have no dynamite to ignite.\n") ;
  699.     return ;
  700. }
  701.  
  702. /* deal with spurious "light cap with match" */
  703. if (tag[V_cap]&&(object[O_dynamite][J_loc] != B_have)&& 
  704.     (object[O_cap][J_loc] != B_have)) {
  705. printf("You don't have one to ignite.\n") ;
  706.     return ;
  707. }
  708.  
  709. /* light up the match(es) */
  710.     if (tag[V_PLURAL]) {
  711. printf("You open up the match box and strike ALL of the matches.\n");
  712.         object[O_matches][J_loc] = B_destroyed ;
  713.     }
  714.     else {
  715. printf("You take one match from the match box and ignite it.\n") ;
  716.     }
  717. }
  718.  
  719. /* see if player selected burnable objects */
  720. if (tag[V_cap]&&(object[O_cap][J_loc] == B_have)) {
  721. printf("You then ignite the fuse of the blasting cap.\n\n"); 
  722. printf("Ssssssssssssssssssssssss........\n");
  723.     clock_explode = time(0) + 11 ;
  724.     sw_clock = TRUE ;
  725.     flag_clock = V_cap ;
  726.     return ;
  727. }
  728.  
  729. if ((tag[V_cap]||tag[V_dynamite])&&
  730.     (object[O_dynamite][J_loc] == B_have)) {
  731.     if (object[O_dynamite][J_type] == Z_alias) {
  732. printf("You then ignite the fuse of the dynamite's blasting cap....\n");
  733. printf("You need to very quickly get very far away from this thing!!");
  734. printf("\n\nSsssssssssssssssssssssss........\n");
  735.         clock_explode = time(0) + 11 ;
  736.         sw_clock = TRUE ;
  737.         flag_clock = V_dynamite ;
  738.          return ;
  739.     }
  740.     else {
  741. printf("You then ignite the dynamite. Which is an odd thing\n"); 
  742. printf("to do since it doesn't have a blasting cap in it.  The\n");
  743. printf
  744.   ("\"dynamite\" (which is actually a very safe mining explosive)\n");
  745. printf("burns for a few minutes, billowing out smelly black smoke\n");
  746. printf("and eventually goes out leaving a few scant ashes behind.\n") ;
  747.         object[O_dynamite][J_loc] = B_destroyed ;
  748.          return ;
  749.     }
  750. }
  751.  
  752. } /* -- end of the "igniter" subroutine --- */
  753.  
  754. void hold_it()
  755. /********************************************/
  756. /*                                          */
  757. /*            Wait Subroutine               */
  758. /*                                          */
  759. /*     Software by Gary A. Allen, Jr.       */
  760. /*           Version: Mk 1.00               */
  761. /* (c) Copyright 1989 by Gary A. Allen, Jr. */
  762. /*                                          */
  763. /********************************************/
  764.  
  765. {
  766. #if (PROTOTYPE)
  767. char getch(void) ;
  768. #endif
  769.  
  770. #ifdef __TURBOC__
  771. /* Stop scrolling the screen until the user is ready */
  772. printf("               [Press any key to continue]\r") ;
  773. getch() ;
  774. printf("                                          \n") ;
  775. #endif
  776.  
  777. #ifndef __TURBOC__
  778. printf("               [Press RETURN to continue]\n") ;
  779. getchar() ;
  780. #endif
  781.  
  782. } /* --- end of the "hold_it" subroutine --- */
  783.  
  784. void eater()
  785. /********************************************/
  786. /*                                          */
  787. /*            Eater Subroutine              */
  788. /*                                          */
  789. /*     Software by Gary A. Allen, Jr.       */
  790. /*           Version: Mk 1.00               */
  791. /* (c) Copyright 1989 by Gary A. Allen, Jr. */
  792. /*                                          */
  793. /********************************************/
  794. {
  795.  
  796. #if (PROTOTYPE)
  797. void ender(int) ;
  798. #endif
  799.  
  800. /* reject single verb command */
  801. if (tag[V_VERB_ONLY]) {
  802.     printf("What exactly do you want me to swallow?\n") ;
  803.     return ;
  804. }
  805.  
  806. /* deal with "eat (atropine) pill(s)" command */
  807. if (tag[V_pill]) {
  808.     if (object[O_pills][J_loc] != B_have) {
  809. printf("You don't have the atropine pills in your possesion!\n") ;
  810.         return ;
  811.     }
  812.     if (tag[V_PLURAL]) {
  813. printf("You remove ALL of the pills from the packet and swallow\n");
  814. printf("the lot.  For a couple of minutes nothing happens, then you\n");
  815. printf("start seeing double and have nervous twitches. You then\n");
  816. printf("start shaking violently and collapse to the ground.\n") ;
  817. printf("Eventually you pass out and expire from atropine poisoning.\n");
  818.         ender(F_died) ;
  819.     }
  820.     if (--pill_count <= 0 ) {
  821.         object[O_pills][J_loc] = B_destroyed ;
  822.         carry_count-- ;
  823.         carry_weight -= object[O_pills][J_weight]  ;
  824. printf("You swallow the last atropine pill and throw away the empty\n");
  825. printf("packet which disappears from sight.  ") ;
  826.     }
  827. else printf("You swallow one atropine pill.  ") ;
  828.         i_poison += 10 ;
  829.         if (i_poison >= 30) {
  830. printf("\nAfter a moment you have a violent seizure and die.\n") ;
  831.             ender(F_died) ;
  832.         }
  833.         if (i_poison >= 20) {
  834. printf("\nYou begin to shake violently and can barely stand.\n") ;
  835.             return ;
  836.         }
  837.         if (i_poison >= 15) {
  838. printf("\nYour hands become a bit jittery and your vision blurred.\n") ;
  839.             return ;
  840.         }
  841.         printf("The drug has no ill effect.\n") ;
  842.     return ;
  843. }
  844. else 
  845. printf("I am not inclined towards putting that into my mouth!\n") ;
  846.  
  847. } /* --- end of the "eater" subroutine --- */
  848.  
  849. void ender(i_quit)
  850. /********************************************/
  851. /*                                          */
  852. /*            Ender Subroutine              */
  853. /*                                          */
  854. /*     Software by Gary A. Allen, Jr.       */
  855. /*           Version: Mk 1.00               */
  856. /* (c) Copyright 1989 by Gary A. Allen, Jr. */
  857. /*                                          */
  858. /********************************************/
  859.  
  860. int i_quit ;
  861. {
  862. #if (PROTOTYPE)
  863. void hold_it(void), new_score(void), exit(int) ;
  864. #endif
  865.  
  866. /* get last score */
  867. new_score() ;
  868.  
  869. if (gleep_score != 0) sw_active = TRUE ; 
  870.  
  871. if (i_quit == F_died) { 
  872.     hold_it() ;
  873.     score -= 100 ;
  874. printf ("\nOh Dear!  You've just turned yourself into a corpse! \n\n");
  875. printf ("For getting killed you lose 100 points. \n\n") ;
  876. }
  877.  
  878. /* Scoring Block */
  879. for(;;) {
  880. if (!sw_active) {
  881.     if (score == 0) { 
  882.         printf("You concluded the game with no points.  ") ; 
  883.         printf("What a pitiful performance!!\n") ;
  884.     }
  885.     else {
  886. printf("You concluded the game with a miserable negative score\n") ;
  887. printf("of %d points.  Your score was better BEFORE you \n",score);
  888. printf("started playing (need I say more on how this reflects\n");
  889. printf("upon your limited aptitude at Dinkum).\n") ;
  890.     }
  891.     break ;  /* drop out of the scoring block */
  892. }
  893.  
  894. if (score == 0)  {
  895. printf("You concluded the game with no points ") ;
  896.     if (gleep_score == 0) { 
  897. printf("and didn't drop a single gleep\n") ;
  898. printf("into the gleep tank. The word \"embarrassing\" sums it up!\n") ;
  899.     }
  900.     else {
  901.         if (gleep_score > 1) {
  902. printf("but you did put %d gleeps\n",gleep_score) ;
  903. printf("into the gleep tank.\n") ;
  904.         }
  905.         else {
  906. printf("but you did manage to find a gleep\n") ;
  907. printf("and put it in the gleep tank, (Hah!! What an achievement!).\n");
  908.         }
  909.     }
  910. }
  911.  
  912. else {
  913. if (score > 0)
  914. printf ("You concluded the game with %d points",score);
  915. else {
  916. printf("You concluded the game with a miserable negative score\n") ;
  917. printf("of %d points.  Your score was better BEFORE you \n",score);
  918. printf("started playing (need I say more on how this reflects\n");
  919. printf("upon your limited aptitude at Dinkum).  You ") ;
  920.     if (gleep_score == 0) { 
  921. printf("also failed to\nget any gleeps into the tank.  At least ");
  922. printf("you're consistent.\n\n") ;
  923.     }
  924.     else {
  925. printf("managed\nto get something into the gleep tank.  However ");
  926. printf("it hardly\nmatters, considering your poor score.\n\n") ;
  927.     }
  928.     break ;  /* drop out of the scoring block */
  929. }
  930.     if (gleep_score == 0) 
  931. printf(".\nHowever you placed no gleeps in the gleep tank.\n") ;
  932.     else {
  933.         if (gleep_score > 1) {
  934. printf (" and placed %d gleeps\n",gleep_score) ;
  935. printf ("in the gleep tank.  Good on you, Mate!\n") ;
  936.         }
  937.         else {
  938. printf(" but you did manage to find a gleep\n") ;
  939. printf("and put it in the gleep tank.\n") ;
  940.         }
  941.     }
  942. }
  943. break ;  /* drop out of the scoring block */
  944. } /* end of the scoring block */
  945.  
  946. /* Closing Remark */
  947. printf("\nDinkum has ended.  If you are interested in more ") ;
  948. printf("information\nabout this program type:    dinkum -h\n") ;
  949. exit(0);
  950.  
  951. } /* --- end of "ender" routine --- */
  952.