home *** CD-ROM | disk | FTP | other *** search
/ ST-Computer Leser 2002 January / STC_CD_01_2002.iso / GAMES / BOINKO21 / SRC / SRC / BOUT4.C < prev    next >
C/C++ Source or Header  |  2000-11-27  |  12KB  |  534 lines
  1. /********************************************
  2. *        Bout4.c                                *
  3. *                                            *
  4. *        Based Upon code by                    *
  5. *        Samuel Streeper 90/01/26            *
  6. *                                            *
  7. *    Original Version                        *
  8. *    Copyright 1990 by Antic Publishing Inc.    *
  9. *                                            *
  10. *    Miscellaneous boinkout routines            *
  11. *                                            *
  12. ********************************************/
  13.  
  14. /* edited with tabsize = 4 */
  15.  
  16. #include <stdlib.h>
  17. #include <stdio.h>
  18. #include <string.h>
  19.  
  20. #include "boink.h"
  21.  
  22. extern MFDB digitsource, windsource, pic_buf, ballsource, levelsource;
  23. extern int brickarray[], level, lives, num_balls;
  24. extern void ball_ani(register BALL_STRUCT *p);
  25. extern void fuji_ani(register BALL_STRUCT *p);
  26. extern void eye_ani(register BALL_STRUCT *p);
  27. extern int appear[], gl_hbox;
  28. extern int num_bricks, ani_count, paddle_x;
  29. extern int paddle_y, pad_y_max, pad_y_min, n_redraws, paddlearray[];
  30. extern int max_xspeed, magic_bottom, mode, gravity;
  31. extern int text_ht, fuji_ht, fmask_ht, ball_ht;
  32. extern int bh, btw, bleft, bth, btop, pad_ht, planes, pad_y_top, cheat;
  33. extern char brickcount[];
  34. extern long score, bonus_life;
  35. extern BALL_STRUCT bs[];
  36. extern GRECT region[];        /* a list of redraw regions */
  37.  
  38. extern void clear(int x,int y,int w,int h);
  39.  
  40. void restore_level(void);
  41.  
  42. int invis;
  43.  
  44.  
  45. void
  46. prinl(register long num,int x,int y,int fill)
  47. {
  48.     register int ndx = 0;
  49.     char buf[10];
  50.  
  51.     /* make sure the number is in the acceptable range */
  52.  
  53.     if ((num < 0L) || (num > 9999999L)) num = 0L;
  54.  
  55.     /* if number is zero, be sure to show one digit */
  56.     if (!num) buf[ndx++] = 0;
  57.  
  58.     /* build the number in reverse order */
  59.     while (num)
  60.     {
  61.         buf[ndx++] = (num % 10);
  62.         num /= 10;
  63.     }
  64.  
  65.     if (fill)
  66.     {    x += 8 * (7-ndx);
  67.     }
  68.  
  69.     while (--ndx >= 0)
  70.     {
  71.         brickarray[0] = buf[ndx] * 8;
  72.         brickarray[1] = 0;
  73.         brickarray[2] = brickarray[0] + 7;
  74.         brickarray[3] = text_ht - 1;
  75.         brickarray[4] = x;
  76.         brickarray[5] = y;
  77.         brickarray[6] = x + 7;
  78.         brickarray[7] = y + text_ht - 1;
  79.  
  80.         vro_cpyfm(vdi_handle,S_ONLY,brickarray,&digitsource,&pic_buf);
  81.  
  82.         vro_cpyfm(vdi_handle,S_ONLY,brickarray,&digitsource,&windsource);
  83.  
  84.         x += 8;
  85.     }
  86. }
  87.  
  88. void
  89. show_score(void)
  90. {
  91.     prinl(score,372,2,TRUE);
  92.     add_region(work.g_x+372,work.g_y+2,7*8,text_ht);
  93.     if (score >= bonus_life)
  94.     {
  95.         sound_play(S_BONUS);
  96.         bonus_life += BONUS;
  97.         lives++;
  98.         show_lives();
  99.     }
  100. }
  101.  
  102. void
  103. show_lives(void)
  104. {
  105.     prinl((long)lives,25,2,FALSE);
  106.     add_region(work.g_x+25,work.g_y+2,7*8,text_ht);
  107. }
  108.  
  109. void
  110. show_level(void)
  111. {
  112.     prinl((long)level+1,170 + 6*8,2,FALSE);
  113.     add_region(work.g_x+(170 + 6*8),work.g_y+2,7*8,text_ht);
  114. }
  115.  
  116. void
  117. clear_areas(void)
  118. {
  119.     /* put a ball in the corner */
  120.     brickarray[0] = brickarray[1] = brickarray[4] = brickarray[5] = 0;
  121.     brickarray[2] = brickarray[6] = 20;
  122.     brickarray[3] = brickarray[7] = ball_ht - 1;
  123.  
  124.     vro_cpyfm(vdi_handle,S_ONLY,brickarray,&ballsource,&pic_buf);
  125.  
  126.     /* clear lives area */
  127.     clear(21,0,4*8,text_ht + 4);
  128.  
  129.     /* clear level area */
  130.     clear(168,0,10*8,text_ht + 4);
  131.  
  132.     /* clear score area */
  133.     clear(375,0,7*8,text_ht + 4);
  134.  
  135.     /* put in word 'level' */
  136.     brickarray[0] = brickarray[1] = 0;
  137.     brickarray[2] = 8*5 - 1;
  138.     brickarray[3] = text_ht - 1;
  139.     brickarray[4] = 170;
  140.     brickarray[5] = 2;
  141.     brickarray[6] = 170 + 39;
  142.     brickarray[7] = 2 + text_ht - 1;
  143.  
  144.     vro_cpyfm(vdi_handle,S_ONLY,brickarray,&levelsource,&pic_buf);
  145. }
  146.  
  147. char afn[] = {BALL,EYE,BALL,FUJI,BALL,EYE,BALL,EYE    };
  148.  
  149. void
  150. add_ball(int x,int y,int xspeed,int yspeed,int allow_fuji)
  151. {
  152.     register BALL_STRUCT *p;
  153.     int ndx;
  154.  
  155.     if (num_balls >= MAX_BALLS) return;
  156.  
  157.     ndx = (int)(rand() & 7);
  158.     p = &bs[num_balls];
  159.  
  160.     switch(afn[ndx])
  161.     {
  162.         case BALL:                /* ball */
  163. b1:            p->id = BALL;
  164.             p->ani_funct = ball_ani;
  165.             p->ball_ht = ball_ht;
  166.             p->ball_wid = 20;
  167.             p->half_ht = ball_ht / 2;
  168.             p->half_wid = 10;
  169.             break;
  170.  
  171.         case FUJI:
  172.             if (!allow_fuji) goto b1;
  173.             p->id = FUJI;
  174.             p->ani_funct = fuji_ani;
  175.             p->ball_ht = fmask_ht;
  176.             p->ball_wid = 16;
  177.             p->half_ht = fmask_ht / 2;
  178.             p->half_wid = 8;
  179.             break;
  180.  
  181.         case EYE:
  182.             p->id = EYE;
  183.             p->ani_funct = eye_ani;
  184.             p->ball_ht = ball_ht;
  185.             p->ball_wid = 20;
  186.             p->half_ht = ball_ht / 2;
  187.             p->half_wid = 10;
  188.             break;
  189.     }
  190.  
  191.     p->y = y;
  192.     p->x = p->array[4] = x;
  193.     p->array[5] = p->y;
  194.     p->array[6] = x + p->ball_wid;
  195.     p->array[7] = y + p->ball_ht - 1;
  196.     p->xspeed = xspeed;
  197.     p->yspeed = yspeed;
  198.     p->spin_dir = 1;
  199.  
  200.     num_balls++;
  201. }
  202.  
  203. void
  204. kill_ball(int i)
  205. {
  206.     register BALL_STRUCT *p;
  207.     register int x;
  208.  
  209.     p = &bs[i];
  210.  
  211.     p->l = p->array[0] = p->array[4];
  212.     p->t = p->array[1] = p->array[5];
  213.     p->r = p->array[2] = p->array[6];
  214.     p->b = p->array[3] = p->array[7];
  215.  
  216.     /* Restore the background picture to its virgin state    */
  217.     /* i.e.  remove the image of the ball from it.            */
  218.  
  219.     vro_cpyfm(vdi_handle,mode,p->array,&pic_buf,&windsource);
  220.     add_region(work.g_x + p->l, work.g_y + p->t,
  221.         p->r - p->l + 1, p->b - p->t + 1);
  222.  
  223.  
  224.     num_balls--;
  225.     for (x=i;x<num_balls;x++) bs[x] = bs[x+1];
  226. }
  227.  
  228.  
  229. /********************************************/
  230. /* magic - make something weird happen        */
  231. /********************************************/
  232. char mfn[] = {0,1,0,2,0,3,0,4};
  233.  
  234. void
  235. magic(int i)
  236. {
  237.     register BALL_STRUCT *p;
  238.     register int j, ts;
  239.     int ndx, count;
  240.  
  241.     p = &bs[i];
  242.     gravity = 0;
  243.  
  244.     ndx = (int)(rand() & 7);
  245.     if (mode == BLACKMODE || invis)
  246.     {
  247.         if ((num_balls >= MAX_BALLS))
  248.         {
  249.             if (mode == BLACKMODE && cheat) restore_level();
  250.             return;
  251.         }
  252.  
  253.         restore_level();
  254.         ndx = 0;
  255.     }
  256.  
  257.     switch(mfn[ndx])
  258.     {
  259.         case 0:        /*** multiple balls ***/
  260.             ts = p->xspeed;
  261.             if (ts <= -max_xspeed) ts = -max_xspeed + 1;
  262.             else if (ts >= max_xspeed) ts = max_xspeed - 1;
  263.  
  264.             /* get random # of balls */
  265.             count = (int)(rand() & 3);
  266.             if (!count) count = 1;
  267.             if (num_balls >= 3) count = 1;
  268.  
  269.             for (j=0; j<count; j++)
  270.             {
  271.                 add_ball(p->x,p->y+1-j,ts+1-j,p->yspeed,TRUE);
  272.             }
  273.             break;
  274.  
  275.         case 1:        /*** magic bottom ***/
  276.             magic_bottom += 2;
  277.             break;
  278.  
  279.         case 2:        /*** bricks invisible ***/
  280.             invis = TRUE;
  281.             brickarray[0] = brickarray[1] = brickarray[4] = brickarray[5] = 0;
  282.             brickarray[2] = brickarray[6] = work.g_w;
  283.             brickarray[3] = brickarray[7] = work.g_h;
  284.             vro_cpyfm(vdi_handle,S_ONLY,brickarray,&pic_buf,&windsource);
  285.             n_redraws = 0;
  286.             add_region(work.g_x,work.g_y,work.g_x+work.g_w,work.g_y+work.g_h);
  287.             break;
  288.  
  289.         case 3:        /*** background black ***/
  290.             brickarray[0] = brickarray[1] = brickarray[4] = brickarray[5] = 0;
  291.             brickarray[2] = brickarray[6] = work.g_w;
  292.             brickarray[3] = brickarray[7] = work.g_h;
  293.             vro_cpyfm(vdi_handle,ALL_BLACK,brickarray,&pic_buf,&windsource);
  294.             mode = BLACKMODE;
  295.             show_score();
  296.  
  297.             n_redraws = 0;
  298.             add_region(work.g_x,work.g_y,work.g_x+work.g_w,work.g_y+work.g_h);
  299.             break;
  300.  
  301.          case 4:        /*** gravity ***/
  302.              gravity=1;
  303.              break;
  304.  
  305.     }
  306. }
  307.  
  308. /********************************************/
  309. /* restart a level without restoring        */
  310. /* brick counts                                */
  311. /********************************************/
  312. void
  313. cont_level(void)
  314. {
  315.     register int x, y, image, ndx;
  316.  
  317.     if (win[GAME_WIN].handle == NO_WINDOW) return;
  318.  
  319.     clear_areas();
  320.  
  321.     num_bricks = 0;
  322.     
  323.     brickarray[0] = brickarray[1] = brickarray[4] = brickarray[5] = 0;
  324.     brickarray[2] = brickarray[6] = pic_buf.fd_w - 1;
  325.     brickarray[3] = brickarray[7] = pic_buf.fd_h - 1;
  326.     vro_cpyfm(vdi_handle,S_ONLY,brickarray,&pic_buf,&windsource); 
  327.  
  328.     show_lives();
  329.     show_level();
  330.     show_score();
  331.  
  332.     brickarray[1] = 0;
  333.     brickarray[3] = bh - 1;
  334.  
  335.     ndx = 0;
  336.     for (y=0; y<7; y++)
  337.     {
  338.         for (x=0; x < 9; x++)
  339.         {
  340.             brickarray[0] = 0;
  341.             brickarray[2] = 43;
  342.             brickarray[4] = bleft + x * btw;
  343.             brickarray[5] = btop + y * bth;
  344.             brickarray[6] = brickarray[4] + 43;
  345.             brickarray[7] = brickarray[5] + bh - 1;
  346.  
  347.             switch(brickcount[ndx])
  348.             {
  349.                 case 9:        /* permanent */
  350.                     vrt_cpyfm(vdi_handle, MD_TRANS, brickarray,&permbrickmask,&windsource,junkcolors);
  351.                     vro_notcpy(brickarray, &permbricksource, &windsource);
  352.                     break;
  353.  
  354.                 case 1:            /* normal */
  355.                     num_bricks++;
  356.                     break;
  357.  
  358.                 case 2:            /* magic */
  359.                     vrt_cpyfm(vdi_handle, MD_TRANS, brickarray,&twobrickmask,&windsource,junkcolors);
  360.                     vro_notcpy(brickarray, &magicbricksource, &windsource);
  361.  
  362.                     num_bricks++;
  363.                     break;
  364.  
  365.                 case 3:
  366.                 case 4:
  367.                 case 5:
  368.                 case 6:
  369.                     num_bricks++;
  370.                     break;
  371.             }
  372.             ndx++;
  373.         }
  374.     }
  375.  
  376.     n_redraws = 0;
  377.     add_region(work.g_x,work.g_y,work.g_w,work.g_h);
  378.     do_redraw();
  379.  
  380.     evnt_timer(150,0);
  381.  
  382.     sound_play(S_APPEAR);
  383.  
  384.     evnt_timer(150,0);
  385.  
  386.     for (image = 3; image >= 0; image--)
  387.     {
  388.         ndx = 0;
  389.         brickarray[0] = image * btw;
  390.         brickarray[2] = brickarray[0] + 43;
  391.  
  392.         for (y=0; y<7; y++)
  393.         {
  394.             for (x=0; x < 9; x++)
  395.             {
  396.                 brickarray[4] = bleft + x * btw;
  397.                 brickarray[5] = btop + y * bth;
  398.                 brickarray[6] = brickarray[4] + 43;
  399.                 brickarray[7] = brickarray[5] + bh - 1;
  400.  
  401.                 switch(brickcount[ndx++])
  402.                 {
  403.                     case 1:
  404.                         vrt_cpyfm(vdi_handle, MD_TRANS, brickarray,&nbrickmask,&windsource,junkcolors);
  405.                         vro_notcpy(brickarray, &bricksource, &windsource);
  406.                         break;
  407.                     case 3:
  408.                     case 4:
  409.                     case 5:
  410.                     case 6:
  411.                         if (image > 0)
  412.                         {
  413.                             vrt_cpyfm(vdi_handle, MD_TRANS, brickarray,&twobrickmask,&windsource,junkcolors);
  414.                             vro_notcpy(brickarray, &twobricksource, &windsource);
  415.                         }
  416.                         break;
  417.                 }
  418.             }
  419.         }
  420.         add_region(work.g_x,work.g_y,work.g_w,work.g_h);
  421.         do_redraw();
  422.     }
  423.     evnt_timer(500,0);
  424.  
  425.     ani_count = 0;
  426.     paddle_x = 0;
  427.     paddle_y = pad_y_max;
  428.     paddlearray[4] = 0;
  429.     paddlearray[5] = pad_y_max;
  430.     paddlearray[6] = 52;
  431.     paddlearray[7] = pad_y_max + pad_ht;
  432.  
  433.     num_balls = 0;
  434.     add_ball(0, pad_y_min - ball_ht, 2, 2, FALSE);
  435.     mode = BNORMAL;
  436.     invis = FALSE;
  437.      gravity = 0;
  438. }
  439.  
  440.  
  441. /********************************************/
  442. /* restore a level in progress to normal    */
  443. /* and keep playing                            */
  444. /********************************************/
  445. void
  446. restore_level(void)
  447. {
  448.     register int x, y, ndx;
  449.  
  450.     mode = BNORMAL;
  451.     invis = FALSE;
  452.  
  453.     clear_areas();
  454.  
  455.     brickarray[0] = brickarray[1] = brickarray[4] = brickarray[5] = 0;
  456.     brickarray[2] = brickarray[6] = pic_buf.fd_w - 1;
  457.     brickarray[3] = brickarray[7] = pic_buf.fd_h - 1;
  458.     vro_cpyfm(vdi_handle,S_ONLY,brickarray,&pic_buf,&windsource); /* windsource */
  459.     
  460.     show_lives();
  461.     show_level();
  462.     show_score();
  463.  
  464.     brickarray[1] = 0;
  465.     brickarray[3] = bh - 1;
  466.  
  467.     ndx = 0;
  468.     for (y=0; y<7; y++)
  469.     {
  470.         for (x=0; x < 9; x++)
  471.         {
  472.             brickarray[4] = bleft + x * btw;
  473.             brickarray[5] = btop + y * bth;
  474.             brickarray[6] = brickarray[4] + 43;
  475.             brickarray[7] = brickarray[5] + bh - 1;
  476.  
  477.             switch(brickcount[ndx])
  478.             {
  479.                 case 9:        /* permanent */
  480.                     brickarray[0] = 0;
  481.                     brickarray[2] = 43;
  482.                     vrt_cpyfm(vdi_handle, MD_TRANS, brickarray,&permbrickmask,&windsource,junkcolors);
  483.                     vro_notcpy(brickarray, &permbricksource, &windsource);
  484.                     break;
  485.  
  486.                 case 1:            /* normal */
  487.                     brickarray[0] = 0;
  488.                     brickarray[2] = 43;
  489.  
  490.                     vrt_cpyfm(vdi_handle, MD_TRANS, brickarray,&nbrickmask,&windsource,junkcolors);
  491.                     vro_notcpy(brickarray, &bricksource, &windsource);
  492.                     break;
  493.  
  494.                 case 2:            /* magic */
  495.                     brickarray[0] = 0;
  496.                     brickarray[2] = 43;
  497.                     vrt_cpyfm(vdi_handle, MD_TRANS, brickarray,&twobrickmask,&windsource,junkcolors);
  498.                     vro_notcpy(brickarray, &magicbricksource, &windsource);
  499.                     break;
  500.  
  501.                 case 3:
  502.                 case 4:
  503.                 case 5:
  504.                 case 6:
  505.                     brickarray[0] = btw;
  506.                     brickarray[2] = btw + 43;
  507.                     
  508.                     vrt_cpyfm(vdi_handle, MD_TRANS, brickarray,&twobrickmask,&windsource,junkcolors);
  509.                     vro_notcpy(brickarray, &twobricksource, &windsource);
  510.                     break;
  511.             }
  512.             ndx++;
  513.         }
  514.     }
  515.  
  516.     n_redraws = 0;
  517.     add_region(work.g_x,work.g_y,work.g_w,work.g_h);
  518.     do_redraw();
  519. }
  520.  
  521.  
  522. void
  523. add_difficulty(void)
  524. {
  525.     if (level <= 17)
  526.     {
  527.         /* restrict upper paddle limit */
  528.         pad_y_top++;
  529.  
  530.         if (desk.g_h > 300) pad_y_top++;
  531.  
  532.     }
  533. }
  534.