home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 October / usenetsourcesnewsgroupsinfomagicoctober1994disk2.iso / games / volume11 / pc-xbd / part01 / xbd.c < prev    next >
C/C++ Source or Header  |  1990-12-17  |  5KB  |  284 lines
  1. /*********************************************/
  2. /* you just keep on pushing my luck over the */
  3. /*          BOULDER        DASH              */
  4. /*                                           */
  5. /*     Jeroen Houttuin, ETH Zurich, 1990     */
  6. /*                                           */
  7. /*                                           */
  8. /*      PC-VGA version from :                */
  9. /*                                           */
  10. /*        Herve SOULARD, Paris, 1990        */
  11. /*                                           */
  12. /*********************************************/
  13.  
  14. #include <stdio.h>
  15. #include <conio.h>
  16. #include <ctype.h>
  17. #include <dos.h>
  18. #include <graph.h>
  19.  
  20. #include "xbd.h"
  21.  
  22.  
  23.  
  24. void (interrupt far *oldVect)();
  25.  
  26. int count = 0;
  27. Bool startCount = FALSE;
  28. Bool newLevel = FALSE;
  29.  
  30.  
  31. void far interrupt newClock()
  32. {
  33.     if (startCount && count)
  34.         count--;
  35.     _chain_intr(oldVect);
  36. }
  37.  
  38.  
  39. Bool kbdHit(void)
  40. { 
  41.     if (*kbdPtrRead == *kbdPtrWrite)
  42.         return(FALSE);
  43.     else
  44.         return(TRUE);
  45. }
  46.  
  47. void getKbd(byte *TT,byte *T)
  48. { 
  49.     *T = *(kbdBuffer + *kbdPtrRead);
  50.     if (*T == 0x00 || *T == 0xE0) {
  51.         *T = *(kbdBuffer + *kbdPtrRead + 1);
  52.         *TT = 'F';
  53.     }
  54.     else
  55.         *TT = 'T';
  56.     *kbdPtrRead += 2;
  57.     if (*kbdPtrRead == 0x3E)
  58.         *kbdPtrRead = 0x1E;
  59. }
  60.  
  61.  
  62. void init_vars()
  63. {
  64.     blobbreak = 100;
  65.     critical = 100;
  66.     blobcells = 0;
  67.     curorder = STAND;
  68.     gamestop = TRUE;
  69.     scoreobs = TRUE;
  70.     stoplevel = FALSE;
  71.     levelnum = 1;
  72.     speed = 1;
  73.     lives = 4;
  74.     xin = 0;
  75.     yin = 0;
  76.     players = 1;
  77. }
  78.  
  79.  
  80. void adapt_timer()
  81. {
  82.     if (speed <= 0)
  83.         speed = 1;
  84.     count = 34 / speed;
  85. }
  86.  
  87.  
  88.  
  89. /* Handle a key stroke by the user. */
  90. void handle_key(byte keytype, byte keyhit)
  91. {
  92.     if (players <= 0) {
  93.         init_level(levelnum);
  94.         adapt_timer();
  95.         stoplevel = FALSE;
  96.         draw_field(TRUE);
  97.         gamestop = TRUE;
  98.         players = 1;
  99.         return;
  100.     }
  101.     if (keytype == 'T') {
  102.         switch (keyhit) {
  103.             case K_SPACE:
  104.                 gamestop = !gamestop;
  105.                 break;
  106.         }
  107.     }
  108.     else {
  109.         switch (keyhit) {
  110.             case K_LEFT:
  111.                 curorder = LEFT;
  112.                 gamestop = FALSE;
  113.                 break;
  114.             case K_UP:
  115.                 curorder = UP;
  116.                 gamestop = FALSE;
  117.                 break;
  118.             case K_DOWN:
  119.                 curorder = DOWN;
  120.                 gamestop = FALSE;
  121.                 break;
  122.             case K_RIGHT:
  123.                 curorder = RIGHT;
  124.                 gamestop = FALSE;
  125.                 break;
  126.         }
  127.     }
  128. }
  129.  
  130.  
  131. /* Function which is called whenever the timer signal goes off */
  132. void ticker()
  133. {
  134.     startCount = FALSE;
  135.     if (curtime)
  136.         curtime--;
  137.     if (tinkact)
  138.         tinkdur--;
  139.     if (curtime % 10 == 1)
  140.         scoreobs = TRUE;
  141.  
  142.     if (!gamestop) {
  143.         if (newLevel) {
  144.             newLevel = FALSE;
  145.             _clearscreen(_GCLEARSCREEN);
  146.         }
  147.         calculate_field();
  148.         draw_field(0);
  149.     }
  150.     if (stoplevel) {
  151.         init_level(levelnum);
  152.         adapt_timer();
  153.         gamestop = TRUE;
  154.         stoplevel = FALSE;
  155.         newLevel = TRUE;
  156.     }
  157.     adapt_timer();
  158.     startCount = TRUE;
  159. }
  160.  
  161.  
  162.  
  163.  
  164. void main(argc, argv)
  165. int argc;
  166. char **argv;
  167. {
  168.     long        period;
  169.     char        buf[50];
  170.     int        i;
  171.  
  172.     byte    keyhit;
  173.     byte    keytype;
  174.     
  175.     init_vars();
  176.  
  177.     /* scan the command line for executing parameters and flags */
  178.     for (i = 1; i < argc; ++i) {
  179.         if (argv[i][0] == '-') {
  180.             if (argv[i][1] == 'l') {
  181.                 if (argv[i][2] == '\0' && i + 1 < argc) {
  182.                     sscanf(argv[i + 1], "%d", &levelnum);
  183.                     i++;    
  184.                 } 
  185.                 else
  186.                     sscanf(argv[i] + 2, "%d", &levelnum);
  187.             } 
  188.             else {
  189.                 printf("usage: xbd [-l <level>] \n");
  190.                 exit(1);
  191.             }
  192.         }
  193.     }
  194.  
  195.     levelstart = levelnum;
  196.     init_level(levelnum);
  197.  
  198.     oldVect = _dos_getvect(0x1C);
  199.     xstart();
  200.  
  201.     load();
  202.     
  203.     make_gcs();
  204.     _clearscreen(_GCLEARSCREEN);
  205.     draw_field(TRUE);
  206.     draw_score();
  207.  
  208.     /* initialize timer structure according to speed */
  209.     adapt_timer();
  210.  
  211.     startCount = FALSE;
  212.     _dos_setvect(0x1C,newClock);
  213.     
  214.     while (lives > 0) {        /* MAIN LOOP */
  215.         if (!count) 
  216.             ticker();
  217.         if (kbdHit()) {
  218.             getKbd(&keytype,&keyhit);
  219.             if (keytype == 'T') {
  220.                 switch (keyhit) {
  221.                     case K_ESC:
  222.                         xend();
  223.                         _dos_setvect(0x1C,oldVect);
  224.                         add_score();
  225.                         exit(-1);
  226.                         break;
  227.                     case K_D:
  228.                     case K_d:
  229.                         curorder = KILL;
  230.                         break;
  231.                     case K_R:
  232.                     case    K_r:
  233.                         _clearscreen(_GCLEARSCREEN);
  234.                         draw_field(TRUE);
  235.                         break;
  236.                     default:
  237.                         handle_key(keytype,keyhit);
  238.                         break;
  239.                 }
  240.             }
  241.             /*
  242.                 Handle of CTRL key is to be done
  243.                 
  244.             if ((*kbdStatus & 0x0F) == CTL_SHIFT) {
  245.                 steal = TRUE;
  246.                 if (keytype == 'T') {
  247.                     switch (keyhit) {
  248.                         case K_C:
  249.                         case K_U:
  250.                         case K_c:
  251.                         case K_u:
  252.                             xend();
  253.                             _dos_setvect(0x1C,oldVect);
  254.                             add_score();
  255.                             exit(-1);
  256.                             break;
  257.                         case K_D:
  258.                         case K_d:
  259.                             curorder = KILL;
  260.                         case K_R:
  261.                         case    K_r:
  262.                             draw_field(TRUE);
  263.                             break;
  264.                         default:
  265.                             handle_key(keytype,keyhit);
  266.                             break;
  267.                     }
  268.                 }
  269.             }
  270.             */
  271.             else
  272.                 handle_key(keytype,keyhit);
  273.         }
  274.         if (!gamestop)
  275.             startCount = TRUE;
  276.     }
  277.     xend();
  278.     _dos_setvect(0x1C,oldVect);
  279.     add_score();
  280.     exit(-1);
  281. }
  282.  
  283.  
  284.