home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 January / usenetsourcesnewsgroupsinfomagicjanuary1994.iso / sources / games / volume15 / dinkum2 / part03 / taker.c < prev   
C/C++ Source or Header  |  1993-01-27  |  31KB  |  1,101 lines
  1. #define TAKER
  2. #include "dink_sym.h"
  3. #include "dink_glb.h"
  4.  
  5. void taker(n)
  6. /*********************************************************/
  7. /*                                                       */
  8. /*           --- Object Taking Subroutine ---            */
  9. /*                                                       */
  10. /*      Program by Gary A. Allen, Jr.   20 May 1990      */
  11. /*        (c) Copyright 1992 by Gary A. Allen, Jr.       */
  12. /*                                                       */
  13. /*********************************************************/
  14. int n ;
  15. {
  16. register int i, j ;
  17. int  sw_done, gleep_holder, ammo_flag ;
  18.  
  19. #if (PROTOTYPE)
  20. void clip_in(int), clip_out(int), ender(int), eater(void) ;
  21. #endif
  22.  
  23. /* Alias in the object for the single word "take" command */
  24. if (tag[V_VERB_ONLY]) {
  25.     j = 0 ;
  26.     /* See if there is only one object on the floor */
  27.     for (i = 0; i <= objcnt; i++) if (n == object[i][J_loc]) {
  28.         j++ ;
  29.         tag[object[i][J_parse_id]] = TRUE ;
  30.     }
  31.  
  32.     if (room[n][M_gleep] != 0) {
  33.         j++ ;
  34.         tag[V_gleep] = TRUE ;
  35.         if (room[n][M_gleep] > 1) tag[V_PLURAL] = TRUE ;
  36.     }
  37.  
  38.     /* Complain if there isn't a single object on the ground */
  39.     if (j > 1) {
  40.         printf ("What exactly do you want me to take? \n");
  41.         return ;
  42.     }
  43. }
  44.  
  45. ammo_flag = F_no_clip ;
  46. if (tag[V_clip]) ammo_flag = F_normal_clip ;
  47. if (tag[V_org_clip]) ammo_flag = F_org_clip ;
  48.  
  49. /* deal with special case of "orange clip" implied by its being alone */
  50. if (tag[V_clip]&&(object[O_clip][J_loc] != n)&&
  51.    (object[O_org_clip][J_loc] == n)) {
  52.     tag[V_org_clip] = TRUE ;
  53.     tag[V_clip] = FALSE ;
  54.     if (V_clip == sent[1]) sent[1] = V_org_clip ;
  55. }
  56.  
  57. /* deal with the verb "attach" */
  58. if (verb == V_attach) {
  59.     if (tag[V_rifle]&&(ammo_flag != F_no_clip)) {
  60.         clip_in(ammo_flag) ;
  61.         return ;
  62.     }
  63.     if ((n != R_office_mang)&&(room[n][M_obj_cnt] <= 0)) {
  64.         printf ("There is nothing here that I can attach!\n");
  65.         return ;
  66.     }
  67. }
  68.  
  69. /* Check to see if player already has the item */
  70. for (i = 0; i <= objcnt; i++) { 
  71.     if (object[i][J_parse_id] == sent[1]) {
  72.         if (object[i][J_loc] == B_have) {
  73. printf ("You already have a %s in your possession.\n",vocab[sent[1]-1]);
  74.             return ;
  75.         }
  76.         else break ;
  77.     }
  78. }
  79.  
  80. sw_done = FALSE ;
  81.  
  82. if (tag[V_safe]) {
  83.     if (n != R_office_mang) {
  84.         printf("There is no safe here. \n") ;
  85.         return ;
  86.     }
  87.     if (room[R_office_mang][M_rm_status] != S_open) {
  88.         printf("I can't do it because the safe is closed. \n") ;
  89.         return ;
  90.     }
  91. }
  92.  
  93. /* Special case of "take pill" */
  94. if ((tag[V_pill])&&(object[O_pills][J_loc] == B_have)) {
  95.     eater() ;
  96.     return ;
  97. }
  98.  
  99. /* Reject "take" command when there is nothing to take */
  100. if ((n != R_office_mang)&&(verb != V_attach)&&(verb != V_remove)&&
  101.     (room[n][M_obj_cnt] <= 0)&&(room[n][M_gleep] == 0)&&
  102.     (!((n == R_gleep_tank)&&(gleep_score > 0)))&&
  103.     (room[n][M_rm_type] != T_unmovable_obj)) {
  104.     printf ("There is nothing here that you can take! \n");
  105.     return ;
  106. }
  107.  
  108. /* player takes something from the gleep tank */
  109. if (tag[V_tank]) {
  110.     if (n != R_gleep_tank) {
  111. printf("I see no gleep tank to take anything from. \n") ;
  112.         return ;
  113.     }
  114. printf("\nYou climb up onto the edge of the gleep tank and reach\n");
  115. printf("into the dark blue fluid.  Suddenly the fluid begins a\n");
  116. printf("furious boiling that instantly reduces your hand into\n") ;
  117. printf("bleached white bones.  The shock and pain disturbs your\n");
  118. printf("balance and you fall into the horrible stuff!!  There is\n");
  119. printf("once again a furious boiling.  Eventually the fluid stills\n");
  120. printf("and becomes clear again.  On the bottom of the tank can\n") ;
  121. printf("be seen a white, clean, \"medical school quality\" human\n");
  122. printf("skeleton.\n") ;
  123.     ender(F_died) ;
  124. }
  125.  
  126. /* gleep taking routine */
  127. if (tag[V_gleep]) {
  128. if (!tag[V_safe]) {
  129.  
  130.     /* This block is for inaccessible or nonexistant gleeps */
  131.     if ((room[n][M_gleep] == 0)&&(!((n == R_office_mang)&&
  132. (room[R_office_mang][M_rm_status] == S_open)&&(gleep_safe != 0)))) {
  133.  
  134.         if ((n != R_gleep_tank)||(gleep_score == 0)) {
  135. printf("There are no gleeps here to take!\n") ;
  136.             return ;
  137.         }
  138.         else {
  139. printf("There are no gleeps on the floor but I see ") ;
  140.             if (gleep_score == 1) 
  141.                 printf("a gleep in the gleep tank.\n");
  142.             else
  143. printf("%d gleeps in the gleep tank.\n",gleep_score) ;
  144.             return ;
  145.         }
  146.     }
  147.  
  148.     /* This block is for accessible gleeps */
  149.     if ((n == R_office_mang)&&
  150. (room[R_office_mang][M_rm_status] == S_open)&&(gleep_safe != 0)) {
  151.         gleep_holder = gleep_safe ;
  152.     }
  153.     else gleep_holder = 0 ;
  154.  
  155.     if ((!tag[V_PLURAL])||
  156.         (room[n][M_gleep]+gleep_holder == 1)) {
  157.         printf("Gleep taken. \n") ; 
  158.         ++gleep_count ;
  159.         if (gleep_holder == 0) --room[n][M_gleep] ;
  160.         else --gleep_holder ;
  161.     }
  162.     else {
  163.         printf("Gleeps taken. \n") ; 
  164.         gleep_count += room[n][M_gleep] + gleep_holder ;
  165.         room[n][M_gleep] = 0 ;
  166.         gleep_holder = 0 ;
  167.     }
  168.     gleep_safe = gleep_holder ;
  169.     return ;
  170. }
  171. else {
  172.     if ((n == R_office_mang)&&
  173. (room[R_office_mang][M_rm_status] == S_open)&&(gleep_safe != 0)) { 
  174.         if (tag[V_PLURAL]) {
  175.             printf("Gleeps taken from safe. \n") ; 
  176.             gleep_count += gleep_safe ;
  177.             gleep_safe = 0 ;
  178.         }
  179.         else {
  180.             printf("Gleep taken from safe. \n") ; 
  181.             ++gleep_count ;
  182.             --gleep_safe ;
  183.         }
  184.     }
  185.     else printf("There are no gleeps in the safe!\n") ;
  186.     return ;
  187. }
  188. } /* end of the gleep taking block */
  189.  
  190. /* deal with the special case of the platypus picture */
  191. if ((n == R_office_mang) && tag[V_picture]) {
  192. printf("The picture can not be removed.  It appears to be hinged ");
  193. printf("to the wall. \n");
  194.     return ;
  195. }
  196.  
  197. /* treat the verb "remove" in the context of "remove clip from rifle" */
  198. if (verb == V_remove) {
  199.     if ((!tag[V_safe])&&(ammo_flag != F_no_clip)) {
  200.         clip_out(n) ;
  201.         return ;
  202.     }
  203. }
  204.  
  205. if (carry_count > 5) {
  206. printf("I can't do it!\n") ;
  207. printf("I'm holding so many things that I can't take anymore!\n") ;
  208.     return ;
  209. }
  210.  
  211. if (carry_weight >= 800) {
  212. printf("I can't do it!\n") ;
  213. printf("This junk I'm carrying is too heavy! I can't carry anymore!\n");
  214.     return ;
  215. }
  216.  
  217.  
  218. /* find the object(s) in this room */
  219. for (i = 0; i <= objcnt; i++) {
  220.  
  221.     if ((carry_count > 5)||(carry_weight >= 800)) break ;
  222.  
  223.     /* See if the object is in the safe and was requested */
  224.     if ((n == R_office_mang)&&(object[i][J_loc] == B_in_safe)&&
  225.         (tag[object[i][J_parse_id]]||tag[V_all])&&
  226.     (room[R_office_mang][M_rm_status] == S_open)&&
  227.     ((!tag[V_treasure])||(object[i][J_value] > 0))) {
  228.         object[i][J_loc] = B_have; 
  229.         carry_count++ ;
  230.         carry_weight += object[i][J_weight] ; 
  231.         sw_done = TRUE ;
  232.     } 
  233.     
  234.     /* See if the object is in the room and was requested */
  235.     if ((object[i][J_loc] == n)&&(tag[object[i][J_parse_id]]||
  236.         tag[V_all])&&
  237.         ((!tag[V_treasure])||(object[i][J_value] > 0))) {
  238.         /* see if the object can be taken */
  239.         if ((object[i][J_type] == Z_normal)||
  240.             (object[i][J_type] == Z_alias)) {
  241.             --room[n][M_obj_cnt] ;
  242.             carry_count++ ;
  243.             carry_weight += object[i][J_weight] ; 
  244.             object[i][J_loc] = B_have; 
  245.             sw_done = TRUE ;
  246.         } 
  247.  
  248.         /* see if this is a nonmovable, nonacting object */
  249.         if ((object[i][J_type] == Z_unmovable) &&
  250.             (object[i][J_loc] == n) && (!tag[V_all])) {
  251.  
  252.             switch(object[i][J_parse_id]) {
  253.             case V_bulldust:
  254. printf("The bulldust is so fine that it wafts away with a touch.\n") ;
  255.                 return ;
  256.  
  257.             /* Silver gong */
  258.             case V_gong:
  259. printf("The siver gong is about three metres in diameter and weighs at\n") ;
  260. printf("least a ton!  There is no way I could move it, let alone get\n") ;
  261. printf("it through the tunnel!\n") ;
  262.                 return ;
  263.  
  264.             /* Cockroach(es) */
  265.             case V_cockroach:
  266. printf("I will not touch the filthy things!\n") ;
  267.                 return ;
  268.  
  269.             /* Kangaroo(s) */
  270.             case V_kangaroo:
  271. printf("I will not touch a dead maggoty kangaroo!  ") ;
  272. printf("The smell is bad enough!\n") ;
  273.                 return ;
  274.  
  275.             case V_poster:
  276. printf("I think this sort of poster is best left on the wall.\n") ;
  277.                 return ;
  278.  
  279.             /* Spinifex(es) */
  280.             case V_spinifex:
  281. printf("The thorns on the spinifex are large and nasty.\n") ;
  282. printf("I'll just leave them to roll about.\n") ;
  283.                 return ;
  284.             } /* end of switch block */
  285.         } /* end of nonmovable object block */ 
  286.  
  287.         /* see if taking the object causes special action */
  288.         if (object[i][J_type] == Z_transform) {
  289.             switch(object[i][J_parse_id]) {
  290.             /* ACME doormat */
  291.             case V_mat:
  292. printf("As you lift up the dirty old doormat, you find half \n") ;
  293. printf("hidden in the dust....  a large brass key. \n") ;
  294.                 object[O_mat][J_type] = Z_normal ;
  295.                 carry_count++ ;
  296.                 carry_weight += object[O_mat][J_weight];
  297.                 object[O_mat][J_loc] = B_have;
  298.                 object[O_key][J_loc] =R_office_entr ;
  299.                 sw_done = TRUE ;
  300.                 return ;
  301.  
  302.             /* Map of the ACME Mine */
  303.             case V_map:
  304. printf("As you picked up the old map from the floor, most of it");
  305. printf(" crumbled into \ndust leaving only one small piece. \n") ;
  306.                 object[O_map][J_loc] = B_unmade ;
  307.                 object[O_map_frag][J_loc] = B_have ;
  308.                 carry_count++ ;
  309.             carry_weight += object[O_map_frag][J_weight] ;
  310.                 --room[n][M_obj_cnt] ;
  311.                 sw_done = TRUE ;
  312.                 return ;
  313.             }
  314.         } /* end of the special action block */ 
  315.     } 
  316. } /* end of the object scan loop */
  317.  
  318. /* take all gleeps if any */
  319. if (tag[V_all]&&(!tag[V_treasure])) {
  320.     if (room[n][M_gleep] > 0) { 
  321.         gleep_count += room[n][M_gleep] ;
  322.         room[n][M_gleep] = 0 ;
  323.         sw_done = TRUE ;
  324.     }
  325.     if ((gleep_safe != 0)&&(n == R_office_mang)&&
  326.         (room[R_office_mang][M_rm_status] == S_open)) {
  327.         gleep_count +=  gleep_safe ;
  328.         gleep_safe = 0 ;
  329.         sw_done = TRUE ;
  330.     }
  331. }
  332.  
  333. /* Announce the "take" was successful */
  334. if (sw_done) {
  335.     if (((carry_count > 5)||(carry_weight >= 800))&&(tag[V_all])) 
  336.         printf("You've taken as much as you can.\n") ;
  337.     else printf ("Done \n");
  338. }
  339. /* --or-- announce the "take" was unsuccessful */
  340. else  {
  341.     if (tag[V_all]) printf("I see nothing which I can take.\n") ;
  342.     else { 
  343.         if (tag[V_VERB_ONLY]) 
  344.             printf("What exactly should I take?\n") ;
  345.         else {
  346.             printf ("I don't see a") ;
  347.             if (tag[V_PLURAL]) printf("ny") ;
  348.             printf (" %s around here. \n",vocab[sent[1]-1]);
  349.         }
  350.     }
  351. }
  352. return ;
  353.  
  354. } /* --- end of the "taker" subroutine --- */
  355.  
  356. void loader()
  357. /*********************************************************/
  358. /*                                                       */
  359. /*           --- Rifle Loading Subroutine ---            */
  360. /*                                                       */
  361. /*      Program by Gary A. Allen, Jr.  29 April 1990     */
  362. /*        (c) Copyright 1992 by Gary A. Allen, Jr.       */
  363. /*                                                       */
  364. /*********************************************************/
  365. {
  366.  
  367. int ammo_flag ;
  368.  
  369. #if (PROTOTYPE)
  370. void clip_in(int) ;
  371. #endif
  372.  
  373. /* Reject single verb load command */
  374. if (tag[V_VERB_ONLY]) {
  375. printf("What exactly do you want me to load?\n") ;
  376.     return ;
  377. }
  378. if (!tag[V_rifle]) {
  379. printf("I don't know how I could load that.\n") ;
  380.     return ;
  381. }
  382.  
  383. /* Deal with implied clip type command */
  384. if (!tag[V_clip]) {
  385. if ((object[O_clip][J_loc] != B_have)&&
  386.     (object[O_org_clip][J_loc] == B_have)) ammo_flag = F_org_clip ;
  387. if ((object[O_clip][J_loc] == B_have)&&
  388.      (object[O_org_clip][J_loc] != B_have)) ammo_flag = F_normal_clip ;
  389.     /* the case were there is no clip is found in clip_in */
  390. }
  391.  
  392. /* Deal with specific "load [orange] clip" command */
  393. else {
  394.     if (tag[V_orange]) {
  395.         if (object[O_org_clip][J_loc] == B_have) 
  396.             ammo_flag = F_org_clip ;
  397.         else {
  398. printf("You don't possess the orange ammunition clip.\n") ;
  399.             return ;
  400.         }
  401.     }
  402.     else {
  403.         if (object[O_clip][J_loc] == B_have)
  404.             ammo_flag = F_normal_clip ;
  405.  
  406. /* assume "load clip" with no normal clip implies orange clip */
  407.         else {
  408.             if (object[O_org_clip][J_loc] == B_have) 
  409.                 ammo_flag = F_org_clip ;
  410.             else{
  411. printf("You don't possess an ammunition clip to load.\n") ;
  412.                 return ;
  413.             }
  414.         }
  415.     }
  416. }
  417.  
  418. clip_in(ammo_flag) ;
  419. } /* --- end of the "loader" subroutine --- */
  420.  
  421. void unloader(n)
  422. /*********************************************************/
  423. /*                                                       */
  424. /*          --- Rifle Unloading Subroutine ---           */
  425. /*                                                       */
  426. /*      Program by Gary A. Allen, Jr.  29 April 1990     */
  427. /*        (c) Copyright 1992 by Gary A. Allen, Jr.       */
  428. /*                                                       */
  429. /*********************************************************/
  430. int n ;
  431. {
  432. #if (PROTOTYPE)
  433. void clip_out(int) ;
  434. #endif
  435.  
  436. /* Reject single verb load command */
  437. if (tag[V_VERB_ONLY]) {
  438. printf("What exactly do you want me to unload?\n") ;
  439.     return ;
  440. }
  441. if (!tag[V_rifle]) {
  442. printf("I don't know how I could unload that.\n") ;
  443.     return ;
  444. }
  445. clip_out(n) ;
  446. } /* --- end of the "unloader" subroutine --- */
  447.  
  448. void dropper(n)
  449. /*********************************************************/
  450. /*                                                       */
  451. /*          --- Object Dropping Subroutine ---           */
  452. /*                                                       */
  453. /*      Program by Gary A. Allen, Jr.  21 May 1990       */
  454. /*        (c) Copyright 1992 by Gary A. Allen, Jr.       */
  455. /*                                                       */
  456. /*********************************************************/
  457. int n ;
  458. {
  459. register int i, k ;
  460.  
  461. int sw_possess, sw_done, ammo_flag, sw_object, i_10, i_fract ;
  462. int sw_found ;
  463.  
  464. #if (PROTOTYPE)
  465. void clip_in(int), clip_out(int), boom(void) ;
  466. void objlooker(int), gleeper(int), unlocker(int) ;
  467. void cap_drop(void), dynamite_drop(void), destroy_all(void) ;
  468. void dropped_gun(void) ;
  469. #endif
  470.  
  471. /* respond to "verb only" command */
  472. if (tag[V_VERB_ONLY]) {
  473.     printf ("You'll have to be more specific. \n");
  474.     return ;
  475. }
  476.  
  477. /* deal with special case of "orange clip" implied by its being alone */
  478. if (tag[V_clip]&&(object[O_clip][J_loc] != B_have)&&
  479.     (clip_flag != F_normal_clip)&&
  480.    ((object[O_org_clip][J_loc] == B_have)||(clip_flag == F_org_clip))) {
  481.     tag[V_org_clip] = TRUE ;
  482.     tag[V_clip] = FALSE ;
  483.     if (V_clip == sent[1]) sent[1] = V_org_clip ;
  484. }
  485.  
  486. ammo_flag = F_no_clip ;
  487. if (tag[V_clip])  ammo_flag = F_normal_clip ;
  488. if (tag[V_org_clip])  ammo_flag = F_org_clip ;
  489.  
  490. /* deal with special cases of the verbs */
  491. switch(verb) {
  492. case V_put:
  493.     /* special case of putting (destroying) an object in water */
  494.     if (tag[V_tank]||tag[V_gleep]||tag[V_safe]||
  495.         tag[V_river]||tag[V_billabong]||tag[V_stream]) break ;
  496.  
  497.     /* special case of "put key in door(lock)" */
  498.     if (tag[V_key] && tag[V_door]) {
  499.         unlocker(n) ;
  500.         return ;
  501.     }
  502.  
  503.     if (!tag[V_cap]) {
  504.         if ((!tag[V_rifle])&&(ammo_flag != F_no_clip)) {
  505.             printf("What am I to put the clip into? \n") ;
  506.             return ;
  507.         }
  508.         if (tag[V_rifle]&&(ammo_flag != F_no_clip))  
  509.                 clip_in(ammo_flag) ;
  510.         else 
  511. printf("I don't understand what this is to be put into. \n") ;
  512.         return ;
  513.     }
  514.  
  515. case V_insert:
  516.     if (tag[V_safe]) break ;
  517.     if (ammo_flag != F_no_clip) {
  518.         if (!tag[V_rifle]) {
  519. printf("What am I to insert the clip into? \n") ;
  520.         }
  521.         else {
  522.             clip_in(ammo_flag) ;
  523.         }
  524.         return ;
  525.     }
  526.     if (tag[V_cap]) {
  527.         if (!tag[V_dynamite]) {
  528. printf("I see no reason why I should put a blasting cap into that.\n") ;
  529.             return ;
  530.         }
  531.         /* Cap insertion routine */
  532.         else {
  533.             /* see if your are holding the dynamite or the cap */
  534.             if ((object[O_cap][J_loc] != B_have)&&
  535.                 (object[O_dynamite][J_loc] != B_have)) {
  536. printf("You bloody dill!  You have neither the dynamite or a ");
  537. printf("blasting cap.\n") ;
  538.                 return ;
  539.             }
  540.             if (object[O_cap][J_loc] != B_have) {
  541. printf("You've got the dynamite but you need a blasing cap.\n") ;
  542.                 return ;
  543.             }
  544.                 if (object[O_dynamite][J_loc] != B_have) {
  545. printf("You've got the blasting cap but you need some dynamite.\n") ;
  546.                 return ;
  547.             }
  548. /* transform the two objects into one */
  549. printf("With some trepidation, you slide the blasting cap into\n");
  550. printf("the dynamite.  What you are now holding is VERY dangerous.\n");
  551.             object[O_cap][J_loc] = B_unmade ; 
  552.             object[O_dynamite][J_type] = Z_alias ;
  553.             carry_weight -= object[O_cap][J_weight] ;
  554.             carry_count-- ;
  555.             return ;
  556.         } /* end of the cap insertion block */
  557.     }
  558. printf("I can think of some interesing places to insert this. \n") ;
  559. printf("However I shall not reduce myself to such vulgarity.\n");
  560.     return ;
  561.     
  562. case V_eject:
  563. /* Command "eject clip" ejects clip from rifle no matter what type*/
  564.     if ((ammo_flag == F_normal_clip)&&(clip_flag == F_org_clip)) 
  565.         ammo_flag = F_org_clip ; 
  566. case V_drop:
  567.     if (((ammo_flag == F_org_clip)&&(clip_flag == F_org_clip))|| 
  568.     ((ammo_flag == F_normal_clip)&&(clip_flag == F_normal_clip))) { 
  569.         clip_out(n) ;
  570.         return ;
  571.     }
  572.     break ;
  573.  
  574. } /* end of switch */
  575.  
  576. /* Deal with "drop" when player has no objects */
  577. if (tag[V_all]&&(carry_count == 0)&&(gleep_count == 0)) {
  578.     printf("You dill!  You have nothing to drop!\n") ;
  579.     return ;
  580. }
  581.  
  582. /* deal with "drop in safe ..." errors */
  583. if (tag[V_safe]) {
  584. /* see if this is the managers office */
  585.     if (n != R_office_mang) {        
  586.         printf("There is no safe here! \n");
  587.         return ;
  588.     }
  589. /* See if the safe is open */
  590.     if (room[R_office_mang][M_rm_status] != S_open) {
  591.         printf ("I can't do it!  The safe is closed. \n");
  592.         return ;
  593.     }
  594. }
  595.  
  596. /* gleep droping routine */
  597. if (tag[V_gleep]||tag[V_tank]) {
  598.     /* drop gleeps in a normal way */
  599.     if (!tag[V_tank]) {
  600.         if (gleep_count == 0) { 
  601.             printf("You have no gleeps to drop! \n") ;
  602.             return ;
  603.         }
  604.         if ((!tag[V_PLURAL])||(gleep_count == 1)) {
  605.             if (tag[V_safe]) {
  606.                 printf("Gleep put into safe.\n") ;
  607.                 ++gleep_safe ;
  608.                 --gleep_count ;
  609.             }
  610.             else {
  611.                 printf("Gleep dropped. \n") ; 
  612.                 --gleep_count ;
  613.                 ++room[n][M_gleep] ;
  614.             }
  615.         }
  616.         else {
  617.             if (tag[V_safe]) {
  618.                 printf("Gleeps put into safe.\n") ;
  619.                 gleep_safe += gleep_count ;
  620.                 gleep_count = 0 ;
  621.             }
  622.             else {
  623.                 printf("Gleeps dropped. \n") ; 
  624.                 room[n][M_gleep] += gleep_count ;
  625.                 gleep_count = 0 ;
  626.             }
  627.         }
  628.         gleep_drop = TRUE ;
  629.         return ;
  630.     }
  631.     /* drop objects(including gleeps) into a gleep tank */
  632.     else {
  633.         sw_found = FALSE ;
  634.         if (n != R_gleep_tank) {
  635.             printf("I don't see a gleep tank here. \n") ;
  636.             return ;
  637.         }
  638.         if (tag[V_gleep]) {
  639.             if (gleep_count <= 0) {
  640. printf("You have no gleeps to put in the tank. \n") ; 
  641.                 return ;
  642.             }
  643.             sw_found = TRUE ;
  644.             if ((!tag[V_PLURAL])||(gleep_count == 1)) {
  645. printf("Your gleep falls into the tank with a \"plonk\".\n") ;
  646.                 ++gleep_score ;
  647.                 --gleep_count ;
  648.             }
  649.             if (tag[V_PLURAL]&&(gleep_count > 1)) {
  650. printf("Your gleeps fall into the tank causing a splash.\n") ;
  651.                 gleep_score += gleep_count ;
  652.                 gleep_count = 0 ;
  653.             }
  654.         }
  655.  
  656.         /* drop non-gleeps into the tank */
  657.  
  658.         /* the "drop all" routine */
  659.         if (tag[V_all]) {
  660.             sw_possess = FALSE ;
  661.             for (i = 0; i <= objcnt; i++) {
  662.                 if ((object[i][J_loc] == B_have)&&
  663.                     ((!tag[V_treasure])||
  664.                     (object[i][J_value] > 0))) {
  665.                     sw_possess = TRUE ;
  666.                     object[i][J_loc] = B_destroyed; 
  667.                     carry_count-- ;
  668.                 carry_weight -= object[i][J_weight] ;
  669.                 }
  670.             }
  671.             if (gleep_count == 0) {
  672.                 if (sw_possess) {
  673. printf("You dump everything into the gleep tank. There is a furious\n");
  674. printf("bubbling as the corrosive fluid of the tank turns the\n");
  675. printf("objects into NOTHING.\n") ;
  676.                 }
  677.                 else 
  678. printf("You've got nothing to throw into the tank.\n") ;
  679.             }
  680.             else {
  681.                 if (sw_possess) {
  682. printf("You fling everything into the gleep tank.  The gleep");
  683.                 if (gleep_count > 1) {
  684. printf("s\nsplash into the tank and settle to the bottom of the\n") ;
  685.                 }
  686.                 else {
  687. printf("\nplonks into the tank and settles to the bottom of the\n") ;
  688.                 }
  689. printf("tank.  However the other objects begin to dissolve the\n");
  690. printf("moment the tank's fluid touches them.  Time passes and\n");
  691. printf("the objects dissolve into NOTHING.\n") ;
  692.                 }
  693.                 /* you possess no non-gleeps */
  694.                 else {
  695.                 if (gleep_count == 1) 
  696. printf("Your gleep falls into the tank with a \"plonk\".\n") ;
  697.                 else
  698. printf("Your gleeps fall into the tank causing a splash.\n") ;
  699.                 }
  700.             gleep_score += gleep_count ;
  701.             gleep_count = 0 ;
  702.             }
  703.             return ;
  704.         } /* end of the "drop all" if block */
  705.  
  706.         /* Individual non-gleeps are dropped into the tank */
  707.  
  708.         /* see if your are holding the object(s) */
  709.         for (i=0; i <= objcnt; i++) {
  710.              if (tag[object[i][J_parse_id]]) {
  711.                 if (object[i][J_loc] == B_have) {
  712. printf ("You fling the %s into the gleep tank.  As soon as it\n",
  713.     vocab[object[i][J_parse_id]-1]);
  714. printf ("touched the tank's fluid there was a furious effervescence\n");
  715. printf ("as it began to dissolve.  With the passage of time, the\n") ;
  716. printf ("fluid stills and there is NOTHING left.\n") ;
  717.                     carry_count-- ;
  718.                 carry_weight -= object[i][J_weight] ;
  719.                     object[i][J_loc] = B_destroyed; 
  720.                 }
  721.                 else {
  722. printf("You don't have a %s to toss into the gleep tank.\n",
  723.     vocab[object[i][J_parse_id]-1]);
  724.                 }
  725.                 return ;
  726.             }
  727.         } /* object scan "for" loop */
  728.  
  729.         /* deal with garbage object to drop */
  730. if (!sw_found) printf("I don't understand what you want me to drop.\n") ;
  731.         return ;
  732.     }
  733. }
  734.  
  735. sw_done = FALSE ;
  736.  
  737. /* the "drop all" routine */
  738. if (tag[V_all]) {
  739.  
  740.     /* Deal with throwing stuff into water */
  741.     if(tag[V_stream]) {
  742.         if (n == R_stream) {
  743. printf("You fling everything into the stream.\n");
  744.             destroy_all() ;
  745.             return ;
  746.         }
  747.         else
  748. printf("I see no stream to toss stuff into.\n") ;
  749.         return ;
  750.     }
  751.     if(tag[V_billabong]) {
  752.         if ((n == R_stream)||(n == R_slime)||
  753.             (n == R_billabong)) { 
  754. printf("You fling everything into the billabong.\n");
  755.             destroy_all() ;
  756.             return ;
  757.         }
  758.         else
  759. printf("I see no billabong to toss stuff into.\n") ;
  760.         return ;
  761.     }
  762.     if(tag[V_river]) {
  763.         if ((n == R_dike)||(n == R_river_edge)||
  764.             (n == R_river_exit)) {
  765. printf("You fling everything into the river.\n");
  766.             destroy_all() ;
  767.             return ;
  768.         }
  769.         else
  770. printf("I see no river to toss stuff into.\n") ;
  771.         return ;
  772.     }
  773.  
  774.     if (!tag[V_safe]) {
  775. /* normal drop */
  776. if (room[n][M_rm_type] != T_looping) {
  777.     /* normal room */
  778.     for (i = 0; i <= objcnt; i++) {
  779.         if ((object[i][J_loc] == B_have)&&
  780.             ((!tag[V_treasure]) || (object[i][J_value] > 0))) {
  781.  
  782.         sw_done = TRUE ;
  783.  
  784.         /* see if the blasting cap was hard dropped */
  785.         if ((i == O_cap)&&(verb != V_slow_drop)) {
  786.             cap_drop() ;
  787.             return ;
  788.         }
  789.  
  790. /* see if the dynamite with blasting cap was hard dropped */
  791.         if ((i == O_dynamite)&&(object[O_dynamite][J_type] == Z_alias)
  792.             &&(verb != V_slow_drop)) dynamite_drop() ;
  793.         ++room[n][M_obj_cnt] ;
  794.         carry_count-- ;
  795.         carry_weight -= object[i][J_weight] ;
  796.         object[i][J_loc] = n; 
  797. /* set valuable switch if valuable object dropped in Ned's area */
  798.         if (object[i][J_value] > 0) {
  799.             for (k = 22; k <= 41; k++) 
  800.                 if (k == n) sw_valuable = TRUE;
  801.             for (k = 144; k <= 146; k++) 
  802.                  if (k == n) sw_valuable = TRUE;
  803.         }
  804.     }
  805. }
  806.             /* drop all gleeps */
  807.             if ((gleep_count > 0) &&
  808.                     (!tag[V_treasure])) {
  809.                 room[n][M_gleep] += gleep_count ;
  810.                 gleep_count = 0 ;
  811.                 sw_done = TRUE ;
  812.                 gleep_drop = TRUE ;
  813.             }
  814.  
  815.             if (sw_done) {
  816.                 printf ("Done\n");
  817.                 objlooker(n) ;
  818.                 gleeper(n) ; 
  819.             } 
  820.             else printf("Don't have it to drop.\n") ;
  821.             return ;
  822.         }
  823.         /* object destroyer room */
  824.         else {
  825.         /* Code assumes that player has something to drop */
  826. printf ("You dropped everything you had in a heap, which \n");
  827. printf ("promptly vaporized into a bright blue flash followed \n");
  828. printf ("by a low \"BOOM\". \n") ; 
  829. printf ("       --- You've blown it Bozo!! ---\n") ;
  830.             destroy_all() ;
  831.             return ;
  832.         }
  833.     }
  834.     /* "drop all into the safe" routine */
  835.     else {
  836.         for (i = 0; i <= objcnt; i++) {
  837.             if ((object[i][J_loc] == B_have) &&
  838.                 ((!tag[V_treasure])||
  839.                 (object[i][J_value] > 0))) {
  840.                 object[i][J_loc] = B_in_safe ;    
  841.                 carry_count-- ;
  842.                 carry_weight -= object[i][J_weight] ;
  843.                 sw_done = TRUE ;
  844.             }
  845.         }
  846.         if (!tag[V_treasure]) {
  847.             gleep_safe += gleep_count ;
  848.             gleep_count = 0 ;
  849.             sw_done = TRUE ;
  850.         }
  851.         if (sw_done) printf ("Done \n");
  852.         else printf("You don't have it to put in the safe!\n") ;
  853.         return ;
  854.     }
  855. }
  856.  
  857. /* see if your are holding the object(s) */
  858. for (i=0; i <= objcnt; i++) {
  859.     sw_object = FALSE ;
  860.     if (tag[object[i][J_parse_id]]) {
  861.         sw_object = TRUE ;
  862.          if (object[i][J_loc] == B_have) {
  863.             /* Safe storage routine */
  864.             if (tag[V_safe]) {
  865.                 object[i][J_loc] = B_in_safe ;    
  866. printf ("The %s is now inside the safe. \n", 
  867.     vocab[object[i][J_parse_id]-1]);
  868.                 sw_done = TRUE ;
  869.                 carry_count-- ;
  870.                 carry_weight -= object[i][J_weight] ;
  871.                 continue ;
  872.             }
  873.  
  874.             /* Single 'drop' routine */
  875.             if (tag[V_river]||tag[V_billabong]||
  876.                 tag[V_stream]) {
  877.         /* The object is to be dropped in water */
  878.                 if(tag[V_stream]) {
  879.                     if (n == R_stream) {
  880. printf("You fling the %s into the stream.\n", 
  881.     vocab[object[i][J_parse_id]-1]);
  882.                     carry_count-- ;
  883.                 carry_weight -= object[i][J_weight] ;
  884.                     object[i][J_loc] = B_destroyed; 
  885.                     return ;
  886.                     }
  887.                     else
  888. printf("I see no stream to toss it into.\n") ;
  889.                     return ;
  890.                 }
  891.             if(tag[V_billabong]) {
  892.                 if ((n == R_stream)||
  893.                 (n == R_slime)||(n == R_billabong)) { 
  894. printf("You fling the %s into the billabong.\n",
  895.     vocab[object[i][J_parse_id]-1]);
  896.                     carry_count-- ;
  897.                 carry_weight -= object[i][J_weight] ;
  898.                     object[i][J_loc] = B_destroyed; 
  899.                     return ;
  900.                 }
  901.                 else
  902. printf("I see no billabong to toss it into.\n") ;
  903.                 return ;
  904.             }
  905.             if(tag[V_river]) {
  906.                 if ((n == R_dike)||(n == R_river_edge)||
  907.                     (n == R_river_exit)) {
  908. printf("You fling the %s into the river.\n", 
  909.     vocab[object[i][J_parse_id]-1]);
  910.                     carry_count-- ;
  911.                 carry_weight -= object[i][J_weight] ;
  912.                     object[i][J_loc] = B_destroyed; 
  913.                     return ;
  914.                 }
  915.                 else
  916. printf("I see no river to toss it into.\n") ;
  917.                 return ;
  918.             }
  919.         }
  920.         /* Normal Drop */
  921.         else if (room[n][M_rm_type] != T_looping) {
  922.             if ((i == O_cap)&&(verb != V_slow_drop)) {
  923.                 cap_drop() ;
  924.                 return ;
  925.             }
  926.             if ((i==O_dynamite)&&(verb != V_slow_drop)&&
  927.         (object[O_dynamite][J_type] == Z_alias)) dynamite_drop();
  928.  
  929. /* If the he rifle is dropped.  See if it kills the player */
  930. if (i==O_rifle) {
  931.     if ((clip_flag != F_no_clip) && 
  932. (object[O_rifle][J_property] > 0)) switch(rifle_flag) {
  933.     case F_safety:
  934.         break ;
  935.             
  936.     case F_single:
  937.         printf("\nBam!\n") ;
  938.         dropped_gun() ;
  939.  
  940.     case F_triple:
  941.         printf("\n") ;
  942.         if (object[O_rifle][J_property] >= 3) {
  943.             printf("Bam! Bam! Bam! \n\n") ;
  944.         }
  945.         else {
  946.         for (i = 1; i <= object[O_rifle][J_property]; i++) 
  947.             printf("Bam! ") ;
  948.         }
  949.         dropped_gun() ;
  950.  
  951.     case F_auto:
  952.         printf("\n") ;
  953.         if (object[O_rifle][J_property] >= 30) {
  954.             for (i = 1; i <= 3; i++) 
  955. printf("Bam! Bam! Bam! Bam! Bam! Bam! Bam! Bam! Bam! Bam! \n") ;
  956.         }
  957.         else {
  958.             i_10 = object[O_rifle][J_property]/10 ;
  959.         i_fract = object[O_rifle][J_property]-(i_10*10) ;
  960.             for (i = 1; i <= i_10; i++) 
  961. printf("Bam! Bam! Bam! Bam! Bam! Bam! Bam! Bam! Bam! Bam! \n") ;
  962.             for (i = 1; i <= i_fract; i++) 
  963.                 printf("Bam! ") ;
  964.         }
  965.         dropped_gun() ;
  966.     } /* end of the switch block */
  967. } /* end of "drop rifle" block */
  968.  
  969.             carry_count-- ;
  970.             carry_weight -= object[i][J_weight] ;
  971.             ++room[n][M_obj_cnt] ;
  972.             object[i][J_loc] = n; 
  973.             sw_done = TRUE ;
  974. /* set valuable switch if valuable object dropped in Ned's area */
  975.             if (object[i][J_value] > 0) {
  976.                 for (k = 22; k <= 41; k++) 
  977.                     if (k == n) sw_valuable = TRUE ;
  978.                 for (k = 144; k <= 146; k++) 
  979.                     if (k == n) sw_valuable = TRUE ;
  980.             }
  981.             continue ;
  982.         }
  983.         else {
  984. printf ("As the %s left your possession there was a bright \n",
  985.     vocab[object[i][J_parse_id]-1]);
  986. printf ("blue flash, followed by a low \"BOOM\" as it vaporized \n");
  987. printf ("into nonexistence. \n");
  988.             carry_count-- ;
  989.             carry_weight -= object[i][J_weight] ;
  990.             object[i][J_loc] = B_destroyed; 
  991.             return ;
  992.         }
  993.         }
  994.          if (object[i][J_loc] == B_unmade) continue ;
  995.     } /* end of the object requested block */
  996.     if ((!sw_done)&&sw_object) {
  997. printf("You do not possess a %s.\n", vocab[object[i][J_parse_id]-1]);
  998.         return ;
  999.     }
  1000. } /* end of the object scan loop */
  1001. if (sw_done) {
  1002.     printf ("Done \n");
  1003.     objlooker(n) ;
  1004.     gleeper(n) ; 
  1005. } 
  1006. else 
  1007. printf("I don't understand what it is I'm supposed to drop.\n") ;
  1008.  
  1009. return ;
  1010.  
  1011.  
  1012. } /* --- end of the "dropper" subroutine --- */
  1013.  
  1014. void cap_drop()
  1015. /*********************************************************/
  1016. /*                                                       */
  1017. /*         --- Blasing Cap Dropping Subroutine ---       */
  1018. /*                                                       */
  1019. /*      Program by Gary A. Allen, Jr.  6 December 1992   */
  1020. /*        (c) Copyright 1992 by Gary A. Allen, Jr.       */
  1021. /*                                                       */
  1022. /*********************************************************/
  1023. {
  1024. printf("Bang!! The blasting cap you were carrying detonated when\n") ;
  1025. printf("it hit the ground.  Fortunately no damage was caused.\n") ;  
  1026. object[O_cap][J_loc] = B_destroyed; 
  1027. carry_count-- ;
  1028. carry_weight -= object[O_cap][J_weight] ;
  1029.  
  1030. } /* --- end of the "cap_drop" subroutine --- */
  1031.  
  1032. void dynamite_drop()
  1033. /*********************************************************/
  1034. /*                                                       */
  1035. /*           --- Dynamite Dropping Subroutine ---        */
  1036. /*                                                       */
  1037. /*      Program by Gary A. Allen, Jr.  6 December 1992   */
  1038. /*        (c) Copyright 1992 by Gary A. Allen, Jr.       */
  1039. /*                                                       */
  1040. /*********************************************************/
  1041. {
  1042. #if (PROTOTYPE)
  1043. void ender(int), boom(void) ;
  1044. #endif
  1045.  
  1046. boom() ;
  1047. printf("Dropping a stick of dynamite with a blasting cap in it\n");
  1048. printf("ranks high as one of the dumbest things a person can do.\n") ;
  1049. printf("Needless to say you were blown to bits. Next time drop\n") ;
  1050. printf("the dynamite slowly or gently.\n") ;
  1051. ender(F_died) ;
  1052.  
  1053. } /* --- end of the "dynamite_drop" subroutine --- */
  1054.  
  1055. void destroy_all()
  1056. /*********************************************************/
  1057. /*                                                       */
  1058. /*        --- Destroy Everything Held Subroutine ---     */
  1059. /*                                                       */
  1060. /*      Program by Gary A. Allen, Jr.  6 December 1992   */
  1061. /*        (c) Copyright 1992 by Gary A. Allen, Jr.       */
  1062. /*                                                       */
  1063. /*********************************************************/
  1064. {
  1065. register int i ;
  1066.  
  1067. gleep_count = 0 ;
  1068. carry_count = 0 ;
  1069. carry_weight = 0 ;
  1070. for (i = 0; i <= objcnt; i++) {
  1071.     if (object[i][J_loc] == B_have)  object[i][J_loc] = B_destroyed; 
  1072. }
  1073. } /* --- end of the "destroy_all" subroutine --- */
  1074.  
  1075. void dropped_gun()
  1076. /*********************************************************/
  1077. /*                                                       */
  1078. /*     --- Player Suicides by Dropping Armed Rifle ---   */
  1079. /*                                                       */
  1080. /*      Program by Gary A. Allen, Jr.  31 December 1992  */
  1081. /*        (c) Copyright 1992 by Gary A. Allen, Jr.       */
  1082. /*                                                       */
  1083. /*********************************************************/
  1084. {
  1085. #if (PROTOTYPE)
  1086. void ender(int) ;
  1087. #endif
  1088.  
  1089. printf("\n") ;
  1090. printf("Dropping a loaded and armed automatic rifle is a stupid way\n");
  1091. if ((object[O_rifle][J_property] == 1) || (rifle_flag == F_single)) {
  1092. printf("to commit suicide.  Needless to say you were hit by the\n") ;
  1093. printf("bullet after the rifle went off.\n") ;
  1094. }
  1095. else {
  1096. printf("to commit suicide.  The bullets shot from the rifle fly\n") ;
  1097. printf("around.  One of them bounces back and hits you!\n") ;
  1098. }
  1099. ender(F_died) ;
  1100. } /* --- end of the "dropped_gun" subroutine --- */
  1101.