home *** CD-ROM | disk | FTP | other *** search
/ Collection of Hack-Phreak Scene Programs / cleanhpvac.zip / cleanhpvac / XBD2_SRC.ZIP / XBD2_SRC / SHARED.C < prev    next >
C/C++ Source or Header  |  1991-02-08  |  9KB  |  380 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 <errno.h>
  16. #include <graph.h>
  17. #include <malloc.h>
  18. #include <dos.h>
  19.  
  20. #include "xbd.h"
  21.  
  22. #define    HEIGHT    16
  23. #define    WIDTH    16
  24.  
  25. #define    MAXPGM    23
  26.  
  27.  
  28. extern char    *getenv();
  29.  
  30.  
  31. char *bitmap[MAXPGM];
  32.  
  33. struct videoconfig config;
  34. int size;
  35.  
  36. char *makegc(char pgm[])
  37. {
  38.     char *ptr,c;
  39.     int i,j;
  40.     unsigned r1,r2,r3,r4;
  41.     unsigned *uptr;
  42.     
  43.     ptr = (char *)malloc(size);
  44.     uptr = (unsigned *)ptr;
  45.     if (ptr == NULL) {
  46.         printf ("Erreur allocation (pgms)\n");
  47.         exit(1);
  48.     }    
  49.  
  50.     *ptr = WIDTH;
  51.     *(ptr+2) = HEIGHT;
  52.     *(ptr+1) = *(ptr+3) = 0;
  53.  
  54.     for (i=0; i < HEIGHT;i++) {
  55.         r1 = r2 = r3 = r4 = 0;
  56.         for (j=0; j < WIDTH; j++) {
  57.             c = pgm[(i*WIDTH)+j];
  58.             if (c & 0x01)
  59.                 r1 |= (1 << ((WIDTH-1)-j));
  60.             if (c & 0x02)
  61.                 r2 |= (1 << ((WIDTH-1)-j));
  62.             if (c & 0x04)
  63.                 r3 |= (1 << ((WIDTH-1)-j));
  64.             if (c & 0x08)
  65.                 r4 |= (1 << ((WIDTH-1)-j));
  66.         }
  67.         /*
  68.             For compatibility with _putimage from Microsoft
  69.             
  70.         *(uptr+2+(i*4)) = r1;
  71.         *(uptr+2+(i*4)+1) = r2;
  72.         *(uptr+2+(i*4)+2) = r3;
  73.         *(uptr+2+(i*4)+3) = r4;
  74.         */
  75.  
  76.         /*    Using my own _putimage (drawPgm)
  77.         */
  78.         *(uptr+2+i) = r1;
  79.         *(uptr+2+i+16) = r2;
  80.         *(uptr+2+i+32) = r3;
  81.         *(uptr+2+i+48) = r4;
  82.     }
  83.     for (i=4; i< size; i+=2) {
  84.         c = *(ptr+i);
  85.         *(ptr+i) = *(ptr+i+1);
  86.         *(ptr+i+1) = c;
  87.     }
  88.     return (ptr);
  89. }
  90.  
  91.  
  92. void make_gcs()
  93. {
  94.     pgc = pgc1 = makegc(bitmap[0]);    /* player_pgms        */
  95.     pgc2 = makegc(bitmap[1]);            /* player2_pgms    */
  96.     wgc = Wgc = makegc(bitmap[2]);    /* wall_pgms        */
  97.     Wgc2 = makegc(bitmap[3]);            /* wall2_pgms        */
  98.     sgc = makegc(bitmap[4]);            /* space_pgms        */
  99.     ggc = makegc(bitmap[5]);            /* grass_pgms        */
  100.     dgc = dgc1 = makegc(bitmap[6]);    /* diamond_pgms    */
  101.     dgc2 = makegc(bitmap[7]);            /* diamond2_pgms    */
  102.     Sgc = makegc(bitmap[8]);            /* steel_pgms        */
  103.     bgc = makegc(bitmap[9]);            /* boulder_pgms    */
  104.     xgc = makegc(bitmap[10]);            /* explosion_pgms    */
  105.     lgc = lgc1 = makegc(bitmap[11]);    /* lmonster_pgms    */
  106.     lgc2 = makegc(bitmap[12]);            /* lmonster2_pgms    */
  107.     rgc = rgc1 = makegc(bitmap[13]);    /* rmonster_pgms    */
  108.     rgc2 = makegc(bitmap[14]);            /* rmonster2_pgms    */
  109.     egc = egc1 = makegc(bitmap[15]);    /* eater_pgms        */
  110.     egc2 = makegc(bitmap[16]);            /* eater2_pgms        */
  111.     Egc = Egc1 = makegc(bitmap[8]);    /* steel_pgms        */
  112.     Egc2 = makegc(bitmap[17]);            /* exit2_pgms        */
  113.     ngc = makegc(bitmap[18]);            /* nucbal_pgms        */
  114.     Bgc = Bgc1 = makegc(bitmap[19]);    /* blob_pgms        */
  115.     Bgc2 = makegc(bitmap[20]);            /* blob2_pgms        */
  116.     tgc = tgc1 = makegc(bitmap[2]);    /* wall_pgms        */
  117.     tgc2 = makegc(bitmap[21]);            /* tinkle1_pgms    */
  118.     tgc3 = makegc(bitmap[22]);            /* tinkle2_pgms    */
  119. }
  120.  
  121. void load()
  122. {
  123.     FILE    *map;
  124.     int    i, j, k;
  125.     char    buf[300];
  126.     int    *ptr;
  127.     char *aux;
  128.     int    color[WIDTH];
  129.     
  130.     if (aux = getenv("XBDLIB"))
  131.         strcpy(buf, aux);
  132.     else
  133.         strcpy(buf, LIB);
  134.  
  135.     strcat(buf, "\\");
  136.     strcat(buf,"bitmaps.dat");
  137.     map = fopen(buf,"r");
  138.     if (map == 0) {
  139.         printf("Error opening bitmap file %s\n",buf);
  140.         exit(-1);
  141.     }
  142.     else {
  143.         for (i = 0;i < MAXPGM;i++) {
  144.             fgets(buf,300,map);
  145.             bitmap[i] = (char *)malloc(HEIGHT * WIDTH);
  146.             for (j = 0;j < HEIGHT;j++) {
  147.                 ptr = color;
  148.                 fgets(buf,300,map);
  149.                 sscanf(buf,"%d %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d",
  150.                         ptr++,ptr++,ptr++,ptr++,ptr++,ptr++,ptr++,ptr++,ptr++,
  151.                          ptr++,ptr++,ptr++,ptr++,ptr++,ptr++,ptr);
  152.                 for (k = 0; k < WIDTH;k++)
  153.                     bitmap[i][(j*WIDTH)+k] = (char)color[k];
  154.             }
  155.             fgets(buf,300,map);
  156.  
  157.         }
  158.         fclose(map);
  159.     }
  160. }
  161.  
  162. void init_level(levelnum)
  163. int levelnum;
  164. {
  165.  
  166.     FILE    *levelfile;
  167.     char    buf[300], *ptr;
  168.  
  169.     Egc = Egc1;            /* don't blink EXIT */
  170.     blobcollapse = FALSE;
  171.     blobcells = 0;
  172.     scoreobs = TRUE;
  173.     tinkact = FALSE;
  174.     levincreased = FALSE;
  175.     strcpy(levname, "No_name_for_this_level_yet");
  176.  
  177.     /* Manufaction the file name by starting with the world name and */
  178.     /* appending the level number to it. */
  179.  
  180.     if (ptr = getenv("XBDLIB"))
  181.         strcpy(filename, ptr);
  182.     else
  183.         strcpy(filename, LIB);
  184.  
  185.     strcat(filename, "\\");
  186.     strcat(filename, LEVELPREFIX);
  187.     sprintf(filename + strlen(filename), "%03d", levelnum);
  188.     
  189.     /* Open level file for reading */
  190.     levelfile = fopen(filename, "r");
  191.     
  192.     /* If level file does not exist, use the default level file. */
  193.     if (levelfile == NULL) {
  194.         /* Build the default level name */
  195.  
  196.         if (ptr = getenv("XBDLIB"))
  197.             strcpy(buf, ptr);
  198.         else
  199.             strcpy(buf, LIB);
  200.  
  201.         strcat(buf, "\\");
  202.         strcat(buf, "\\default");
  203.         /* Open default level file for reading */
  204.         levelfile = fopen(buf, "r");
  205.         if (levelfile == NULL) {
  206.             perror(LEVELPREFIX);
  207.             exit(1);
  208.         }
  209.     }
  210.     
  211.     /* Load the first line of the level file */
  212.     if (fgets(buf, 300, levelfile) == NULL)    {
  213.         x = w;
  214.         y = h;
  215.         speed = 15;
  216.         diareq = 12;
  217.         diapoints = 0;
  218.         extradiapoints = 0;
  219.         blobbreak = 200;
  220.         curtime = 1000;
  221.     } 
  222.     else    {
  223.         /* Extract the level parameters */
  224.         sscanf(buf, "%d %d %d %d %d %d %d %d %d %s", &y, &x, &speed, 
  225.               &diareq, &diapoints, &extradiapoints, &blobbreak, 
  226.               &tinkdur, &curtime, levname);
  227.     }
  228.  
  229.     if (xin && yin) {
  230.         x = xin;
  231.         y = yin;
  232.     }                /* read in from editor command line */
  233. /*
  234.  * if (x > w) x = w; if (y > h) y = h; if (x < 2) x = 2; if (y < 1) y = 1;
  235.  * 
  236.  *
  237.  * Iterate through each horizontal line
  238. */
  239.  
  240.     for (i = 0; i < y; ++i) {
  241.         /* Load the next line from the file */
  242.         if (fgets(buf, 300, levelfile) != NULL) {
  243.             /* Go through each horizontal position and copy the data */
  244.             /* into the level array. */
  245.             for (j = 0; j < x; ++j) {
  246.                 /* Break out if line ends prematurely */
  247.                 if (buf[j] == '\n' || buf[j] == '\0')
  248.                     field[i][j].content = STEEL;    /* break; */
  249.                 field[i][j].content = buf[j];
  250.                 field[i][j].changed = TRUE;
  251.                 field[i][j].dir = N;
  252.                 field[i][j].speed = 0;
  253.                 field[i][j].stage = 0;
  254.                 field[i][j].caught = TRUE;
  255.                 field[i][j].checked = FALSE;
  256.             }
  257.         } 
  258.         else
  259.             j = 0;
  260.         for (; j < x; ++j)
  261.             field[i][j].content = STEEL;
  262.     }
  263.     
  264.     /* Close the level file */
  265.     fclose(levelfile);
  266. }
  267.  
  268.  
  269. /* Draw the score and level number */
  270. void    draw_score()
  271. {
  272.     char    buf[200];
  273.     
  274.     /* Build the output string */
  275.     sprintf(buf, "sc:%d lv:%d ls:%d ds:%d dp:%d ti:%d %s", score, levelnum,
  276.                 lives, diareq, diapoints, curtime / 10, levname);
  277.     strncat(buf,"                                         ", 80-strlen(buf));
  278.     _settextposition(y+2,0);
  279.     _outtext(buf);
  280.     scoreobs = FALSE;
  281. }
  282.  
  283.                                             
  284. void xstart()
  285. {
  286.     _setvideomode(_MAXRESMODE);
  287.     _getvideoconfig(&config);
  288.     size = (unsigned int)_imagesize(0,0,WIDTH-1,HEIGHT-1);
  289.  
  290. }
  291.  
  292.  
  293. void    xend()
  294. {
  295.     gamestop = TRUE;
  296.     
  297.     _setvideomode(_DEFAULTMODE);
  298. }
  299.  
  300.  
  301. void    draw_field(redrawall)
  302. Bool    redrawall;
  303. {
  304.     /* Iterate through each horizontal line */
  305.     for (i = y - 1; i >= 0; --i) {
  306.         for (j = 0; j < x; ++j) {
  307.             if (field[i][j].changed || redrawall) {    
  308.                 switch (field[i][j].content) {
  309.                     case GRASS:
  310.                         drawPgm(j, i, ggc, _GPSET);
  311.                         break;
  312.                     case SPACE:
  313.                         drawPgm(j, i, sgc, _GPSET);
  314.                         break;
  315.                     case PLAYER:
  316.                         drawPgm(j, i, pgc, _GPSET);
  317.                         break;
  318.                     case WALL:
  319.                         drawPgm(j, i, wgc, _GPSET);
  320.                         break;
  321.                     case MAGICWALL:
  322.                         drawPgm(j, i, Wgc, _GPSET);
  323.                         break;
  324.                     case DIAMOND:
  325.                         drawPgm(j, i, dgc, _GPSET);
  326.                         break;
  327.                     case BOULDER:
  328.                         drawPgm(j, i, bgc, _GPSET);
  329.                         break;
  330.                     case EXPLOSION:
  331.                         drawPgm(j, i, xgc, _GAND);
  332.                         break;
  333.                     case LMONSTER:
  334.                         drawPgm(j, i, lgc, _GPSET);
  335.                         break;
  336.                     case RMONSTER:
  337.                         drawPgm(j, i, rgc, _GPSET);
  338.                         break;
  339.                     case NUCBAL:
  340.                         drawPgm(j, i, ngc, _GPSET);
  341.                         break;
  342.                     case BLOB:
  343.                         drawPgm(j, i, Bgc, _GPSET);
  344.                         break;
  345.                     case TINKLE:
  346.                         drawPgm(j, i, tgc, _GPSET);
  347.                         break;
  348.                     case EATER:
  349.                         drawPgm(j, i, egc, _GPSET);
  350.                         break;
  351.                     case EXIT:
  352.                         drawPgm(j, i, Egc, _GPSET);
  353.                         break;
  354.                     case STEEL:
  355.                     default:
  356.                         field[i][j].content = STEEL;
  357.                         drawPgm(j, i, Sgc, _GPSET);
  358.                         break;
  359.                 }
  360.                 field[i][j].changed = FALSE;
  361.             }
  362.         }
  363.     }
  364.     if (scoreobs)
  365.         draw_score();
  366. }
  367.  
  368.  
  369. void    set_cell(i, j, content)
  370. int    i, j;
  371. char    content;
  372. {
  373.     field[i][j].content = content;
  374.     field[i][j].speed = 0;
  375.     field[i][j].stage = 0;
  376.     field[i][j].checked = FALSE;
  377.     field[i][j].changed = TRUE;
  378.     field[i][j].caught = TRUE;
  379. }
  380.