home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 January / usenetsourcesnewsgroupsinfomagicjanuary1994.iso / sources / games / volume15 / dinkum2 / part02 / pusher.c < prev   
C/C++ Source or Header  |  1993-01-27  |  19KB  |  601 lines
  1. #define PUSHER
  2. #include "dink_sym.h"
  3. #include "dink_glb.h"
  4.  
  5. void pusher(n_arg) 
  6. /********************************************************************/
  7. /*                                                                  */
  8. /*                  --- The Pusher Subroutine ---                   */
  9. /*                                                                  */
  10. /*  Software by Gary A. Allen, Jr. 14 June 1989,    Version: Mk 1.2 */
  11. /*           (c) Copyright 1988 by Gary A. Allen, Jr.               */
  12. /*                                                                  */
  13. /********************************************************************/
  14. int *n_arg ;
  15. {
  16. register int i ;
  17. int n ;
  18. char file_name[80] ;
  19.  
  20. #if (PROTOTYPE)
  21. void which_button(void) ; 
  22. void lift_moves(void) ; 
  23. void nothing_happens(void) ; 
  24. void cubic(void) ; 
  25. void no_gray(void) ; 
  26. void no_switch(void) ; 
  27. void no_cube(void) ; 
  28. #endif
  29.  
  30. /* pass the room pointer */
  31. n = *n_arg ;
  32.  
  33. /* reject an isolated "push" command */
  34. if (tag[V_VERB_ONLY]) {
  35.     printf ("What exactly do you want me to push? \n");
  36.     return; 
  37. }
  38.  
  39. /* Deal with the recorder */
  40. if ((tag[V_red_button] || tag[V_white_button] || tag[V_green_button])) {
  41.     if (sw_script) {
  42.     if (object[O_recorder][J_loc] == B_have) {
  43.         if (tag[V_red_button]) {
  44.             if (sw_recording || sw_playing) {
  45.                 if (sw_recording) {
  46.                     sw_recording = FALSE;
  47. printf("--- The data recorder has stopped recording. ---\n") ;
  48.                 }
  49.                 else sw_playing = FALSE;
  50.                 fclose(fp) ;
  51.             }
  52.             else printf("Nothing happened!\n") ;
  53.             return ;
  54.         }
  55.         if (tag[V_white_button]) {
  56.             printf("Type in the file name for reading from:  ") ;
  57.             scanf("%s",file_name) ;
  58.             if ((fp = fopen(file_name,"r")) == 0) {
  59. printf("I could not open the file:  %s \n",file_name);
  60. printf("This file probably doesn't exit.\n") ;
  61. printf("Try pressing the white button again and using a different name.\n") ;
  62.             }
  63.             else sw_playing = TRUE ;
  64.             return ;
  65.         }
  66.         if (tag[V_green_button]) {
  67.             printf("Type in the file name for writing to:  ") ;
  68.             scanf("%s",file_name) ;
  69.             if ((fp = fopen(file_name,"w")) == 0) {
  70. printf ("I could not open the file:  %s \n",file_name);
  71. printf("Try pressing the green button again and using a different name.\n") ;
  72.             }
  73.             else {
  74.                 sw_recording = TRUE ;
  75.                 printf("--- Recording ---\n") ;
  76.             }
  77.             return ;
  78.         }
  79.     }
  80.     else printf("You don't have the recorder in your possession!\n") ;
  81.     }
  82.     else printf("I have never seen a button of that color.\n") ;
  83.     return ;
  84. }
  85.  
  86. switch (n) {
  87. /* Lift entrance at the ground level */
  88. case R_lift_entr:
  89.     if (tag[V_gray_button]) {
  90.         no_gray() ;
  91.         return ;
  92.     }
  93.     if (!tag[V_button]) {
  94.         if (!tag[V_blue_button]) {
  95.             printf ("I don't see why I should push that! \n");
  96.         }
  97.         else nothing_happens() ;
  98.         return ;
  99.     }
  100.     if (room[R_lift_entr][M_rm_status] == S_flashing ) {
  101. printf ("You push the call button and there is a loud \"whirr\" from ");
  102. printf ("an electric motor. \nThe massive steel doors slide open ");
  103. printf ("revealing a huge lift that could hold \ntwenty men at once. ");
  104. printf ("The way is now open for you to enter. \n");
  105.         room[R_lift_entr][M_rm_status] = S_open ;
  106.         room[R_lift_entr][2] = R_lift_inside ;
  107.         break ;
  108.     }
  109.     else {
  110.         if (room[R_lift_entr][M_rm_status] == S_open) {
  111. printf ("You push the call button and there is a loud \"whirr\" from ");
  112. printf ("an electric motor. \nThe massive steel doors slide shut, ");
  113. printf ("closing off access to the lift.\n");
  114.             room[R_lift_entr][M_rm_status] = S_flashing ;
  115.             room[R_lift_entr][2] = R_wall ;
  116.             break ;
  117.         }
  118.         else {
  119. printf("You pushed the lift call button, but nothing happened.\n");
  120. printf("I think the electrical power has been turned off at the\n") ;
  121. printf("circuit breaker.\n") ;
  122.         break ;
  123.         }
  124.     }
  125.  
  126. /* Lift Compartment */
  127. case R_lift_inside:
  128.     if (tag[V_gray_button]) {
  129.         no_gray() ;
  130.         return ;
  131.     }
  132.  
  133.     /* scan push sentence */
  134.     /* zero level */
  135.     if (tag[V_0]) {
  136.         if (room[R_lift_inside][M_rm_status]== S_L0) {
  137. printf ("You pushed the flashing button, but nothing happened.\n");
  138.             break ;
  139.         }
  140. printf ("The steel doors slam shut and you feel heavy as the lift ");
  141. printf ("accelerates \nupwards.  Finally the lift jerks to a halt ");
  142. printf ("and the doors whirr open.  \nSunlight is streaming in. ");
  143. printf ("Once again you are breathing the fresh air.\n");
  144.         room[R_lift_inside][M_rm_status] = S_L0;
  145.         room[R_lift_inside][3] = R_lift_entr;
  146.         room[R_lift_inside][7] = R_lift_entr;
  147.         return ;
  148.     }
  149.  
  150.     /* forty-ninth level */
  151.     if (tag[V_49]) {
  152.         if (room[R_lift_inside][M_rm_status]== S_L49) {
  153. printf ("You pushed the forty-nine button, but nothing happened.\n");
  154.             return ;
  155.         }    
  156.         room[R_lift_inside][M_rm_status] = S_L49 ;
  157.         room[R_lift_inside][3] = R_L49_entr;
  158.         room[R_lift_inside][7] = R_L49_entr;
  159.         lift_moves() ;
  160.         return ;
  161.     }
  162.  
  163.     /* sixty-seventh level */
  164.     if (tag[V_67]) {
  165.         if (room[R_lift_inside][M_rm_status]== S_L67) {
  166. printf ("You pushed the sixty-seven button, but nothing happened.\n");
  167.             return ;
  168.         }    
  169.         room[R_lift_inside][M_rm_status] = S_L67;
  170.         room[R_lift_inside][3] = R_L67_entr;
  171.         room[R_lift_inside][7] = R_L67_entr;
  172.         lift_moves() ;
  173.         return ;
  174.     }
  175.  
  176.     /* eighty-second level */
  177.     if (tag[V_82]) {
  178.         if (room[R_lift_inside][M_rm_status]== S_L82) {
  179. printf ("You pushed the eighty-two button, but nothing happened.\n");
  180.             return ;
  181.         }    
  182.         room[R_lift_inside][M_rm_status] = S_L82;
  183.         room[R_lift_inside][3] = R_L82_entr;
  184.         room[R_lift_inside][7] = R_L82_entr;
  185. printf ("The steel doors slam shut and you feel a sense of ");
  186. printf ("weightlessness as \nthe lift plummets down the mine shaft. ");
  187. printf ("Finally the lift comes to a halt \n");
  188. printf ("and the doors whirr open. \n");
  189.         return ;
  190.     }
  191.     if (tag[V_blue_button]) {
  192.         nothing_happens() ;
  193.         return ;
  194.     }
  195. printf ("This lift can go only to levels 0, 49, 67, or 82 \n");
  196.     return ;
  197.  
  198. /* inside the closet at the Iranian Parliament */
  199. case R_closet:
  200.     if (tag[V_gray_button]) {
  201.         no_gray() ;
  202.         return ;
  203.     }
  204.     if (tag[V_blue_button] || tag[V_button]) {
  205.         /* Is the command for the black cube */
  206.         if (object[O_cube][J_loc] != B_have) {
  207.             no_switch() ;
  208.         }
  209. printf("There is a bright flash of light! Then suddenly you are\n");
  210. printf("back in the hexagon chamber of the ancient spaceship.\n\n");
  211.         *n_arg = R_transport ;
  212.     }
  213.     else no_switch() ;
  214.     return ;
  215.  
  216.  
  217. /* the transporter control panel room */
  218. case R_panel:
  219.     if (tag[V_button]) {
  220.         which_button() ;
  221.         return;
  222.     }
  223.     if (tag[V_blue_button]) {
  224.         if (object[O_cube][J_loc]==B_have) cubic() ;
  225.         else no_cube() ;
  226.         return ;
  227.     }
  228.     if (tag[V_gray_button]) {
  229.         if (sw_transport != TRUE) {
  230. printf("Lots of the \"Sanskrit\" text is flashing by on the display\n");
  231. printf("panel's CRTs.  There is a whirring noise coming out of the\n");
  232. printf("equipment around you which is increasing in both loudness\n");
  233. printf("and pitch. You've turned something on, that's for sure!\n") ;
  234.             sw_transport = TRUE ;
  235.         }
  236.         else nothing_happens() ;
  237.         return ;
  238.     }
  239. default:
  240.     /* Semtex explosive detector */
  241.     if (tag[V_detector] || tag[V_yellow_button] ||
  242.         ((object[O_cube][J_loc] != B_have) &&
  243.         (object[O_detector][J_loc] == B_have))) { 
  244.             if (object[O_detector][J_loc] == B_have) {
  245.                 /* press Semtex detector button */
  246. printf("You press the button on the Semtex explosive detector and\n");
  247.                 for (i = 0; i <= 9; i++) {
  248.                     if ((n == i+207)||(n == i+228)) {
  249. if (room[227-i][M_rm_type] == T_lethal) {
  250.     printf("hear a \"beep, beep, beep\".\n") ;
  251.     return ;
  252. }
  253.                     }
  254.                 }
  255.                 printf("the yellow light flashed.\n") ;
  256.             }
  257.             else {
  258. printf("You don't have the detector in your possession.\n") ;
  259.             }
  260.             return ;
  261.         }
  262.         /* Transporter return device */
  263.         if (object[O_cube][J_loc] == B_have) {
  264.             if ((object[O_detector][J_loc] == B_have) && 
  265.                 (!tag[V_blue_button])) {
  266.                     which_button() ;
  267.                     return;
  268.             }
  269.             cubic() ;
  270.             return ;
  271.         }
  272.         if (tag[V_blue_button]) {
  273.             no_cube() ;
  274.             return ;
  275.         }
  276.         if (tag[V_gray_button]) {
  277.             no_gray() ;
  278.             return ;
  279.         }
  280.  
  281. printf ("You can push as much as you like, but nothing will happen.\n");
  282. } /* end of the switch block */
  283. return; 
  284.  
  285. } /* --- end of the "pusher" subroutine --- */
  286.  
  287. void which_button() 
  288. /********************************************************************/
  289. /*                                                                  */
  290. /*  Software by Gary A. Allen, Jr. 8 December 1992  Version: Mk 1.0 */
  291. /*           (c) Copyright 1992 by Gary A. Allen, Jr.               */
  292. /*                                                                  */
  293. /********************************************************************/
  294. {
  295. printf("Which button do you want me to push? \n") ;
  296. return; 
  297. } /* --- end of the "which_button" subroutine --- */
  298.  
  299. void lift_moves() 
  300. /********************************************************************/
  301. /*                                                                  */
  302. /*  Software by Gary A. Allen, Jr. 8 December 1992  Version: Mk 1.0 */
  303. /*           (c) Copyright 1992 by Gary A. Allen, Jr.               */
  304. /*                                                                  */
  305. /********************************************************************/
  306. {
  307. printf ("The steel doors slam shut and you feel the vibration of ");
  308. printf ("the lift \nmoving in its shaft. Finally the lift jerks ");
  309. printf ("to a halt and the doors whirr open. \n");
  310. return; 
  311. } /* --- end of the "lift_moves" subroutine --- */
  312.  
  313. void nothing_happens() 
  314. /********************************************************************/
  315. /*                                                                  */
  316. /*  Software by Gary A. Allen, Jr. 8 December 1992  Version: Mk 1.0 */
  317. /*           (c) Copyright 1992 by Gary A. Allen, Jr.               */
  318. /*                                                                  */
  319. /********************************************************************/
  320. {
  321. printf("Nothing happens!\n");
  322. return; 
  323. } /* --- end of the "nothing_happens" subroutine --- */
  324.  
  325. void cubic() 
  326. /********************************************************************/
  327. /*                                                                  */
  328. /*              Press cube button in wrong place.                   */
  329. /*                                                                  */
  330. /*  Software by Gary A. Allen, Jr. 8 December 1992  Version: Mk 1.0 */
  331. /*           (c) Copyright 1992 by Gary A. Allen, Jr.               */
  332. /*                                                                  */
  333. /********************************************************************/
  334. {
  335. printf("You press the button on the cube but nothing happens.\n");
  336. return; 
  337. } /* --- end of the "cubic" subroutine --- */
  338.  
  339. void no_gray() 
  340. /********************************************************************/
  341. /*                                                                  */
  342. /*  Software by Gary A. Allen, Jr. 8 December 1992  Version: Mk 1.0 */
  343. /*           (c) Copyright 1992 by Gary A. Allen, Jr.               */
  344. /*                                                                  */
  345. /********************************************************************/
  346. {
  347. printf("I see no gray button to push!\n");
  348. return; 
  349. } /* --- end of the "no_gray" subroutine --- */
  350.  
  351. void no_switch() 
  352. /********************************************************************/
  353. /*                                                                  */
  354. /*  Software by Gary A. Allen, Jr. 8 December 1992  Version: Mk 1.0 */
  355. /*           (c) Copyright 1992 by Gary A. Allen, Jr.               */
  356. /*                                                                  */
  357. /********************************************************************/
  358. {
  359. printf("There is nothing here with a push button switch.\n");
  360. return; 
  361. } /* --- end of the "no_switch" subroutine --- */
  362.  
  363. void no_cube() 
  364. /********************************************************************/
  365. /*                                                                  */
  366. /*  Software by Gary A. Allen, Jr. 8 December 1992  Version: Mk 1.0 */
  367. /*           (c) Copyright 1992 by Gary A. Allen, Jr.               */
  368. /*                                                                  */
  369. /********************************************************************/
  370. {
  371. printf("You don't have the black cube with the blue button in your") ;
  372. printf(" possession!\n") ;
  373. return; 
  374. } /* --- end of the "no_cube" subroutine --- */
  375.  
  376.  
  377. void switcher(n) 
  378. /********************************************************************/
  379. /*                                                                  */
  380. /*                --- The Switcher Subroutine ---                   */
  381. /*                                                                  */
  382. /*                                                                  */
  383. /*  Software by Gary A. Allen, Jr. 29 October 1989  Version: Mk 1.4 */
  384. /*           (c) Copyright 1988 by Gary A. Allen, Jr.               */
  385. /*                                                                  */
  386. /********************************************************************/
  387. int n ;
  388. {
  389. int flag_switch, flag_rifle_md ;
  390.  
  391. #if (PROTOTYPE)
  392. void dialer(int) ;
  393. #endif
  394.  
  395. /* deal with single verb commands */
  396. if (tag[V_VERB_ONLY]) {
  397.     if (tag[V_turn]) printf("Turn what?\n") ;
  398.     if (tag[V_set]) printf("Set what?\n") ;
  399.     if (tag[V_select]) printf("Select what?\n") ;
  400.     if (tag[V_switch]) printf("Switch what?\n") ;
  401.     return ;
  402. }
  403.  
  404. /* Deal with changing the safety on the rifle */
  405. if (tag[V_safety]) {
  406.     if (object[O_rifle][J_loc] == B_have) {
  407.         if (tag[V_off]) {
  408.             rifle_flag = F_single ;
  409. printf("The M16 rifle is set to single shot mode ") ;
  410. printf("with the safey off.\n") ;
  411.             return ;
  412.         }
  413.         if (tag[V_on]) {
  414.             rifle_flag = F_safety ;
  415. printf("The M16 rifle's safety has been turned on.\n") ;
  416.             return ;
  417.         }
  418.     printf("How do you want the safety set?\n") ;
  419.     }
  420.     else printf("You're not holding the rifle!\n") ;
  421.     return ;
  422. }
  423.  
  424. /* deal with special case "turn (safe) dial 0 49 67 82" */
  425. if (tag[V_turn] && tag[V_dial] && (!tag[V_rifle])) {
  426.     dialer(n) ;
  427.     return ;
  428. }
  429.  
  430. /* deal with special case "turn safe ..." */
  431. if (tag[V_turn] && (!tag[V_dial]) && tag[V_safe]) {
  432.     if (n != R_office_mang) {
  433. printf("There is no safe here to turn!\n") ;
  434.         return  ;
  435.     }
  436. printf("Since the safe is set in a concrete wall, turning it would\n");
  437. printf("be rather difficult!  Perhaps I should turn the safe's\n") ;
  438. printf("dial instead?\n") ;
  439.     return ;
  440. }
  441.  
  442. /* initialize the local switches */
  443. flag_switch = F_no_argument ; 
  444. if (tag[V_on]) flag_switch = TRUE ;
  445. if (tag[V_off]) flag_switch = FALSE ;
  446. if (verb == V_light) flag_switch = TRUE ;
  447.  
  448. flag_rifle_md = F_no_argument ;
  449. if (tag[V_safe]) flag_rifle_md = F_safety ;
  450. if (tag[V_triple]) flag_rifle_md = F_triple ;
  451. if (tag[V_single]) flag_rifle_md = F_single ;
  452. if (tag[V_auto]) flag_rifle_md = F_auto ;
  453.  
  454. if ((flag_switch == F_no_argument)&&(flag_rifle_md == F_no_argument)) {
  455. printf("You will have to be a little more specific than that. \n") ;
  456.     return ;
  457. }
  458.  
  459. /* see if it is a simple "on/off" power equipment switch command */
  460. if ((!tag[V_torch])&&(!tag[V_rifle])&&
  461.     (flag_rifle_md == F_no_argument)) {
  462. if (n == R_store_room) {
  463.     /* The circuit breaker is switched off */
  464.     if (flag_switch == FALSE) {
  465.     if (room[R_store_room][M_rm_status] == S_off) {
  466.         printf ("The circuit breaker is already turned off! \n");
  467.     }
  468.     else {
  469. printf ("As you pull the switch lever, there is a bright blue \n");
  470. printf ("arc and then all of the lights go out. \n");
  471.         room[R_store_room][M_rm_status] = S_off ;
  472.         room[R_lift_entr][M_rm_status] = S_closed ;
  473.     }
  474.     return;
  475.     }
  476.     /* The circuit breaker is switched on */
  477.     if (flag_switch == TRUE) {
  478.     if (room[R_store_room][M_rm_status] == S_on) {
  479.     printf ("The circuit breaker is already turned on! \n");
  480.     }
  481.     else {
  482. printf ("As you pull the switch lever, there is a loud \"CLUNK\" \n");
  483. printf ("and you see a POWER ON light glowing. \n");
  484.         room[R_store_room][M_rm_status] = S_on ;
  485.         room[R_lift_entr][M_rm_status] = S_flashing ;
  486.     }
  487.     return;
  488.     }
  489. }          
  490.  
  491. /* Deal with a garbage command */
  492. printf("I don't understand what you want me to switch. \n") ;
  493. return ;
  494. } /* end of the simple "on/off" switch group */
  495.  
  496. /* the switch command is to select an M16 rifle firing mode */
  497. if (tag[V_rifle]) {
  498.     if (object[O_rifle][J_loc] == B_have) {
  499.  
  500.         /* turn the rifle on naively */
  501.         if ((flag_switch==TRUE)||
  502.                ((flag_rifle_md==F_safety)&&(flag_switch==FALSE))) {
  503.             if (rifle_flag != F_safety) {
  504. printf("The rifle's safety is already off! \n") ; 
  505.                 return;
  506.             }
  507.             rifle_flag = F_single ;
  508. printf("The M16 rifle has been set to single shot mode. \n") ;
  509.             return ;
  510.         } 
  511. /* turn on the safety */
  512.     if ((flag_switch==FALSE)||
  513.       ((flag_rifle_md==F_safety)&&((flag_switch==TRUE)||
  514.       (flag_switch==F_no_argument)))) {
  515.                 if (rifle_flag == F_safety) {
  516. printf("The rifle's safety is already on! \n") ; 
  517.                 return;
  518.                 }
  519.             rifle_flag = F_safety ;
  520. printf("The M16 rifle's safety has now been turned on. \n") ;
  521.             return ;
  522.     } 
  523.         /* select single shot mode */  
  524.         if (flag_rifle_md == F_single) {
  525.             if (rifle_flag == F_single) {
  526. printf("The rifle has already been set to single shot mode.\n");
  527.                 return;
  528.             }
  529.             rifle_flag = F_single ;
  530. printf("The M16 rifle has been set to single shot mode. \n") ;
  531.             return ;
  532.         } 
  533.         /* select triple fire mode */  
  534.         if (flag_rifle_md == F_triple) {
  535.             if (rifle_flag == F_triple) {
  536. printf("The rifle has already been set to triple fire mode.\n");
  537.                 return;
  538.             }
  539.             rifle_flag = F_triple ;
  540. printf("The M16 rifle has been set to triple fire mode. \n") ;
  541.             return ;
  542.         } 
  543.         /* select to fully automatice mode */
  544.         if (flag_rifle_md == F_auto) {
  545.             if (rifle_flag == F_auto) {
  546. printf("The rifle has already been set to fully automatic.\n");
  547.                 return;
  548.             }
  549.             rifle_flag = F_auto ;
  550. printf("The M16 rifle has been set to fully automatic. \n") ;
  551.             return ;
  552.         } 
  553.     }
  554.     /* This is the rifle nonpossession error handler */
  555.     else {
  556. printf("You don't have a rifle in your possession! \n") ;
  557.         return ;
  558.     }
  559. } /* end of the rifle mode switching block */
  560.  
  561. /* the switch command is to turn the torch off or on. */
  562. if (tag[V_torch]) {
  563.     if (object[O_torch][J_loc] == B_have) {
  564.         /* "switch torch on" command */
  565.         if (flag_switch==TRUE) {
  566.             if (object[O_torch][J_property]) {
  567. printf("The torch is already turned on.\n") ;
  568.                 return ;
  569.             }
  570. printf("An intense beam of light is projected from the torch.\n") ;
  571.             object[O_torch][J_property] = TRUE ;
  572.             return ;
  573.         }
  574.         /* "switch torch off" command */
  575.         if (flag_switch==FALSE) {
  576.             if (!object[O_torch][J_property]) {
  577. printf("The torch isn't switched on.\n") ;
  578.                 return ;
  579.             }
  580. printf("The torch switches off with a \"click\".\n") ;
  581.             object[O_torch][J_property] = FALSE ;
  582.             return ;
  583.         }
  584.     }
  585. printf("You don't have a torch in your possession to switch! \n") ;
  586.     return ;
  587. }
  588.  
  589. } /* --- end of the "switcher" subroutine --- */
  590.  
  591. void new_score() 
  592. /* This subroutine calculates the score based on treasure in the safe */
  593. {
  594. int i ;
  595.     score = 0 ;
  596.  for (i = 0; i <= objcnt; i++) if (object[i][J_loc] == B_in_safe)  {
  597.         score += object[i][J_value] ;
  598.     } ;
  599. } /* --- end of the "new_score" subroutine --- */
  600.  
  601.