home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 January / usenetsourcesnewsgroupsinfomagicjanuary1994.iso / sources / games / volume13 / dr_mario / part01 / meat.c < prev    next >
C/C++ Source or Header  |  1992-01-12  |  5KB  |  204 lines
  1. #include "info.h"
  2.  
  3. void 
  4. meat() /*checks and removes*/
  5. {
  6.     int             terminate();
  7.     int             remove = 0, i ;
  8.     /*remove is flag that we've erased something*/
  9.  
  10.     tcount = 0; /*haven't killed anything yet*/
  11.  
  12.     remove = row(p1->y) + cols(p1->x);
  13.  
  14.     if (cp & 1)
  15.         remove += row(p2->y); /*we're vertical*/
  16.  
  17.     if (!(cp & 1))
  18.         remove += cols(p2->x);/*we're sideways;horizontal if you wish*/
  19.  
  20.     if (terminate())
  21.         return;    /*zap characters and move down pieces if possible
  22.                 terminate returns 0 unless v==0*/
  23.  
  24.     while (remove) { /*did something check if any fallen pieces
  25.                         can remove anything*/
  26.  
  27.         remove = 0;/*reset - we might have to do this more than once*/
  28.  
  29.         /*check everywhere*/
  30.         for (i = 1; i < 17; i++)
  31.             remove += row(i);
  32.         for (i = 1; i < 9; i++)
  33.             remove += cols(i);
  34.         if (remove) /*anything happen?*/
  35.             if (terminate()) /*yup.*/
  36.                 return;
  37.     }
  38. }
  39.  
  40. int 
  41. terminate() /*I'll be back!*/
  42. {
  43.     void            down();
  44.     struct pos     *tp = t; /*tp points to t[0]*/
  45.     int             i;
  46.     wrefresh(w);
  47.  
  48.     if (v == 0)
  49.         return ERR; /*we've killed all the bugs!*/
  50.  
  51.     /*walk through t[48]*/
  52.     for (i = 0; tcount > i; tp++, i++)
  53.         while (tp->y < 18) /*till we're at the bottom*/
  54.             if (mvwinch(w, tp->y, tp->x) != BLANK)
  55.                 break; /*nothing there*/
  56.             else
  57.                 down(tp->y++, tp->x);/*pull down one if we can, then
  58.                                     see if we can do it again*/
  59.  
  60.     tcount = 0;/*no more in t[]*/
  61.     wrefresh(w);
  62.     return 0; /*still got bugs left*/
  63. }
  64.  
  65. void 
  66. down(y, x)
  67.     register int    y, x;
  68. {
  69.     register chtype ad;
  70.     register int    b;
  71.  
  72.     /*if current pos is blank and up is not & not  a bug & we're not at 
  73.     the top,(whew!) we're ok*/
  74.     while (mvwinch(w, y, x) == BLANK && (b = a[y - 1][x]) != 3 && y > 1 &&
  75.            (ad = mvwinch(w, y - 1, x)) != BLANK)
  76.         if (b == 1)
  77.             if (mvwinch(w, y, x + 1) == BLANK) {
  78.                 a[y - 1][x] = a[y - 1][x + 1] = 0;
  79.                 a[y][x] = 1;
  80.                 a[y][x + 1] = 2;
  81.                 down(y, x + 1);/*side piece  - can move down. 
  82.                 use recursion to go up next column
  83.                 (wow. & I thought I'd never use recursion!)*/
  84.             } else
  85.                 return; /*forget it. side piece can't move down*/
  86.         else if (b == 2)
  87.             if (mvwinch(w, y, x - 1) == BLANK) {
  88.                 a[y - 1][x] = a[y - 1][x - 1] = 0;
  89.                 a[y][x] = 2;
  90.                 a[y][x - 1] = 1;
  91.                 down(y, x - 1); /*same thing*/
  92.             } else
  93.                 return;
  94.         else {
  95.             mvwaddch(w, y, x, ad);/*move piece down*/
  96.             mvwaddch(w, --y, x, BLANK);
  97.             wrefresh(w);
  98.         }
  99. }
  100.  
  101. int 
  102. row(y)
  103.     register int    y; /*check rows*/
  104. {
  105.     void            seta();
  106.     register chtype a1, b1;
  107.     register int    x = 0;
  108.     int             status = 0;
  109.  
  110.     while (x < 10) {
  111.         register int    counter = 0;
  112.         do {
  113.             a1 = mvwinch(w, y, x++);
  114.             b1 = mvwinch(w, y, x);
  115.             counter++;
  116.         } while (a1 == b1 && a1 != BLANK);/*keep going till different*/
  117.  
  118.         if (counter < 4) /*less than four in a row?*/    
  119.             continue;
  120.  
  121.         /*put cordinates in t[], increment tcount, check for bugs,
  122.         if bugs increase sc */
  123.         for (; counter > 0; counter--) {
  124.             t[tcount].y = y;
  125.             t[tcount++].x = x - counter;
  126.             mvwaddch(w, y, x - counter, BLANK);
  127.             if (a[y][x - counter] == 3)
  128.                 sc++, v--;
  129.             seta(y, x - counter);
  130.             status = 1; /*so remove knows we did something*/
  131.         }
  132.     }
  133.     return status; 
  134. }
  135.  
  136. void 
  137. seta(y, x)
  138.     int             y, x;
  139. {
  140.     int             lr;
  141.     lr = a[y][x];
  142.     a[y][x] = 0;
  143.     if (lr == 1) 
  144.         a[y][x + 1] = 0; /*if it was laid sideways and was removed
  145.                             free the other side*/
  146.     else if (lr == 2)
  147.         a[y][x - 1] = 0;
  148. }
  149.  
  150. int 
  151. cols(x)
  152.     register int    x; /*basically same as rows*/
  153. {
  154.     void            setac();
  155.     register chtype a1, b1;
  156.     register int    y = 0;
  157.     int             status = 0;
  158.  
  159.     while (y < 18) {
  160.         register int    counter = 0;
  161.         do {
  162.             a1 = mvwinch(w, y++, x);
  163.             b1 = mvwinch(w, y, x);
  164.             counter++;
  165.         } while (a1 == b1 && a1 != BLANK);
  166.         if (counter < 4)
  167.             continue;
  168.  
  169.         t[tcount].y = y - counter;  /*we don't have to check*/
  170.         t[tcount++].x = x;            /*every piece removed*/  
  171.         t[tcount].y = y;              /*when we killed it*/
  172.         t[tcount++].x = x;             /*vertically*/
  173.  
  174.         for (; counter > 0; counter--) {
  175.             mvwaddch(w, y - counter, x, BLANK);
  176.             if (a[y - counter][x] == 3)
  177.                 sc++, v--;
  178.             setac(y - counter, x);
  179.             status = 1;
  180.         }
  181.     }
  182.     return status;
  183. }
  184.  
  185. void 
  186. setac(y, x)
  187.     int             y, x;
  188. {
  189.     int             lr;
  190.     lr = a[y][x];
  191.     a[y][x] = 0;
  192.     if (lr == 1) {
  193.         a[y][x + 1] = 0;
  194.         if (mvwinch(w, y + 1, x + 1) == BLANK)
  195.             t[tcount].y = y + 1, t[tcount++].x = x + 1;
  196.     /*set t[] here because terminate won't check the neighboring cols*/
  197.     } else if (lr == 2) {
  198.         a[y][x - 1] = 0;
  199.         if (mvwinch(w, y + 1, x - 1) == BLANK)
  200.             t[tcount].y = y + 1;
  201.         t[tcount++].x = x - 1;
  202.     }
  203. }
  204.