home *** CD-ROM | disk | FTP | other *** search
/ Collection of Hack-Phreak Scene Programs / cleanhpvac.zip / cleanhpvac / XBD2_SRC.ZIP / XBD2_SRC / XBDE.C < prev    next >
C/C++ Source or Header  |  1991-02-08  |  9KB  |  426 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 <graph.h>
  16.  
  17. #include "xbd.h"
  18.  
  19. #define    HEIGHT    16
  20. #define    WIDTH    16
  21.  
  22. #define    MAXPGM    23
  23.  
  24. char    curchar;
  25.  
  26. char    allPgms[NB_EDIT_PGM];
  27.  
  28.  
  29. Bool kbdHit(void)
  30. { 
  31.     if (*kbdPtrRead == *kbdPtrWrite)
  32.         return(FALSE);
  33.     else
  34.         return(TRUE);
  35. }
  36.  
  37. void getKbd(byte *TT,byte *T)
  38. { 
  39.     *T = *(kbdBuffer + *kbdPtrRead);
  40.     if (*T == 0x00 || *T == 0xE0) {
  41.         *T = *(kbdBuffer + *kbdPtrRead + 1);
  42.         *TT = 'F';
  43.     }
  44.     else
  45.         *TT = 'T';
  46.     *kbdPtrRead += 2;
  47.     if (*kbdPtrRead == 0x3E)
  48.         *kbdPtrRead = 0x1E;
  49. }
  50.  
  51.  
  52. void init_vars()
  53. {
  54.     levelnum = -1;
  55.     xin = 0;
  56.     yin = 0;
  57. }
  58.  
  59.  
  60. /* Save the current level back into a file.    The global variable */
  61. /* filename is used to determine the file name. */
  62.  
  63. void save_level()
  64. {
  65.     FILE          *levelfile;
  66.     char           buf[300];
  67.     register int       i, j;
  68.  
  69.     /* Open the data file */
  70.     levelfile = fopen(filename, "w");
  71.     if (levelfile == NULL) {
  72.         exit(1);
  73.     }
  74.     
  75.     /* Write out the size of the level.  Normal text is used so that */
  76.     /* levels can be easily copied across architectures. */
  77.     fprintf(levelfile, "%d %d %d %d %d %d %d %d %d %s\n", y, x,
  78.             speed, diareq, diapoints, extradiapoints, blobbreak, 
  79.             tinkdur, curtime, levname);
  80.     
  81.     /* Terminate the lines for writing out the horizontal level lines */
  82.     buf[x] = '\n';
  83.     buf[x + 1] = '\0';
  84.     
  85.     /* Iterate through each vertical position */
  86.     for (i = 0; i < y; ++i) {
  87.  
  88.         /* Copy each horizontal line into the output buffer */
  89.         for (j = 0; j < x; ++j)
  90.             buf[j] = field[i][j].content;
  91.         
  92.         /* Write the line out to the file */
  93.         fputs(buf, levelfile);
  94.     }
  95.     
  96.     /* Close the data file */
  97.     fclose(levelfile);
  98. }
  99.  
  100. int getIndex(char c)
  101. {
  102.     int i=0;
  103.     
  104.     while (allPgms[i] != c && i < NB_EDIT_PGM)
  105.         i++;
  106.     if (i == NB_EDIT_PGM)
  107.         return (-1);
  108.     else
  109.         return(i);
  110. }
  111.  
  112. void setCursor(xC,yC)
  113. int xC,yC;
  114. {
  115.     int x,y;
  116.  
  117.     _setcolor(15);
  118.     y = yC * HEIGHT;
  119.     x = xC * WIDTH;
  120.     _rectangle(_GBORDER, x, y, x + WIDTH -1, y + HEIGHT-1);
  121.     _setcolor(0);
  122.     _rectangle(_GBORDER, x+1, y+1, x + WIDTH-2, y + HEIGHT-2);
  123.  
  124. }
  125.  
  126.  
  127. void unsetCursor(xC,yC)
  128. int xC,yC;
  129. {
  130.     switch (field[yC][xC].content) {
  131.         case GRASS:
  132.             drawPgm(xC, yC, ggc, _GPSET);
  133.             break;
  134.         case    SPACE:
  135.             drawPgm(xC, yC, sgc, _GPSET);
  136.             break;
  137.         case PLAYER:
  138.             drawPgm(xC, yC, pgc, _GPSET);
  139.             break;
  140.         case WALL:
  141.             drawPgm(xC, yC, wgc, _GPSET);
  142.             break;
  143.         case MAGICWALL:
  144.             drawPgm(xC, yC, Wgc, _GPSET);
  145.             break;
  146.         case DIAMOND:
  147.             drawPgm(xC, yC, dgc, _GPSET);
  148.             break;
  149.         case BOULDER:
  150.             drawPgm(xC, yC, bgc, _GPSET);
  151.             break;
  152.         case EXPLOSION:
  153.             drawPgm(xC, yC, xgc, _GPSET);
  154.             break;
  155.         case LMONSTER:
  156.             drawPgm(xC, yC, lgc, _GPSET);
  157.             break;
  158.         case RMONSTER:
  159.             drawPgm(xC, yC, rgc, _GPSET);
  160.             break;
  161.         case NUCBAL:
  162.             drawPgm(xC, yC, ngc, _GPSET);
  163.             break;
  164.         case BLOB:
  165.             drawPgm(xC, yC, Bgc, _GPSET);
  166.             break;
  167.         case TINKLE:
  168.             drawPgm(xC, yC, tgc, _GPSET);
  169.             break;
  170.         case EATER:
  171.             drawPgm(xC, yC, egc, _GPSET);
  172.             break;
  173.         case EXIT:
  174.             drawPgm(xC, yC, Egc, _GPSET);
  175.             break;
  176.         case STEEL:
  177.             drawPgm(xC, yC, Sgc, _GPSET);
  178.             break;
  179.     }
  180. }
  181.  
  182. void showLocPgm(int xC, int yC)
  183. {
  184.     char c;
  185.     int i;
  186.     
  187.     c = field[yC][xC].content;
  188.     i = getIndex(c);
  189.     _setcolor(15);
  190.     _rectangle(_GFILLINTERIOR, 615, 22+(i*16), 625, 26+(i*16));
  191. }
  192.  
  193. void unShowLocPgm(int xC, int yC)
  194. {
  195.     char c;
  196.     int i;
  197.     
  198.     c = field[yC][xC].content;
  199.     i = getIndex(c);
  200.     _setcolor(0);
  201.     _rectangle(_GFILLINTERIOR, 615, 22+(i*16), 625, 26+(i*16));
  202. }
  203.  
  204. void drawAllPgm()
  205. {
  206.     drawPgm(37,  1, pgc, _GPSET); allPgms[0] = PLAYER;
  207.     drawPgm(37,  2, sgc, _GPSET); allPgms[1] = SPACE;
  208.     drawPgm(37,  3, lgc, _GPSET); allPgms[2] = LMONSTER;
  209.     drawPgm(37,  4, rgc, _GPSET); allPgms[3] = RMONSTER;
  210.     drawPgm(37,  5, ggc, _GPSET); allPgms[4] = GRASS;
  211.     drawPgm(37,  6, wgc, _GPSET);    allPgms[5] = WALL;
  212.     drawPgm(37,  7, Wgc, _GPSET);    allPgms[6] = MAGICWALL;
  213.     drawPgm(37,  8, dgc, _GPSET);    allPgms[7] = DIAMOND;
  214.     drawPgm(37,  9, Sgc, _GPSET);    allPgms[8] = STEEL;
  215.     drawPgm(37, 10, bgc, _GPSET);    allPgms[9] = BOULDER;
  216.     drawPgm(37, 11, xgc, _GPSET);    allPgms[10] = EXPLOSION;
  217.     drawPgm(37, 12, Egc, _GPSET);    allPgms[11] = EXIT;
  218.     drawPgm(37, 13, egc, _GPSET);    allPgms[12] = EATER;
  219.     drawPgm(37, 14, ngc, _GPSET);    allPgms[13] = NUCBAL;
  220.     drawPgm(37, 15, Bgc, _GPSET);    allPgms[14] = BLOB;
  221.     drawPgm(37, 16, tgc, _GPSET);    allPgms[15] = TINKLE;
  222. }
  223.  
  224.  
  225. /* Main routine for editing levels */
  226. void main(argc, argv)
  227. int    argc;
  228. char    **argv;
  229. {
  230.     register int        i, j;
  231.     int    tmp;
  232.     char    buf[50];
  233.     int    pX = 0,
  234.         pY = 0;
  235.  
  236.     int curPgm = 0;
  237.     
  238.     Bool end = FALSE;
  239.     byte    keyhit;
  240.     byte    keytype;
  241.  
  242.     init_vars();
  243.  
  244.     /* Read in command line options */
  245.     for (i = 1; i < argc; ++i) {
  246.         if (argv[i][0] == '-') {
  247.             
  248.             /* -w sets the level width */
  249.             if (argv[i][1] == 'w') {
  250.                 if (argv[i][2] == '\0' && i + 1 < argc) {
  251.                     sscanf(argv[i + 1], "%d", &xin);
  252.                     i++;
  253.                 } 
  254.                 else
  255.                     sscanf(argv[i] + 2, "%d", &xin);
  256.             }
  257.             
  258.             /* -h sets the level height */
  259.             else 
  260.                 if (argv[i][1] == 'h') {
  261.                     if (argv[i][2] == '\0' && i + 1 < argc) {
  262.                         sscanf(argv[i + 1], "%d", &yin);
  263.                         i++;
  264.                     } 
  265.                     else
  266.                         sscanf(argv[i] + 2, "%d", &yin);
  267.                 }
  268.                 
  269.                 /* -l sets the level number */
  270.                 else 
  271.                     if (argv[i][1] == 'l') {
  272.                         if (argv[i][2] == '\0' && i + 1 < argc) {
  273.                             sscanf(argv[i + 1], "%d", &levelnum);
  274.                             i++;
  275.                         } 
  276.                         else
  277.                             sscanf(argv[i] + 2, "%d", &levelnum);
  278.                     } 
  279.                     else    {
  280.                         printf("usage: xbde [-h <height>] [-w <width>] -l <level> \n");
  281.                         exit(1);
  282.                     }
  283.         }
  284.     }
  285.     
  286.     /* Make sure some value was chosen for the level number.    This */
  287.     /* discourages everybody editing the same level all the time. */
  288.     if (levelnum == -1) {
  289.         printf("usage: xbde [-h <height>] [-w <width>] -l <level> \n");
  290.         exit(1);
  291.     }
  292.     
  293.     /* Load in level data from file. */
  294.     init_level(levelnum);
  295.     
  296.     /* Start up X windows and create all graphics cursors */
  297.     xstart();
  298.  
  299.     load();
  300.     
  301.     make_gcs();
  302.     Egc = Egc2;
  303.     Wgc = Wgc2;
  304.     tgc = tgc3;
  305.     draw_field(TRUE);
  306.  
  307.  
  308.     drawAllPgm();
  309.     _setcolor(15);
  310.     _rectangle(_GFILLINTERIOR, 570, 22+(curPgm*16), 580, 26+(curPgm*16));
  311.     showLocPgm(pX,pY);
  312.  
  313.     
  314.     /* Main event loop */
  315.     while (!end) {
  316.         setCursor(pX, pY);
  317.         if (kbdHit()) {
  318.             getKbd(&keytype,&keyhit);
  319.             if (keytype == 'T') {
  320.                 switch (keyhit) {
  321.                     /* C erases the entire level */
  322.                     case K_C :
  323.                     case K_c :
  324.                         /* Replace level contents with space */
  325.                         for (i = 0; i < y; ++i)
  326.                             for (j = 0; j < x; ++j)
  327.                                 if ((i == 0) || (i == y - 1) 
  328.                                     || (j == 0) || (j == x - 1))
  329.                                     set_cell(i, j, STEEL);
  330.                                 else
  331.                                     set_cell(i, j, SPACE);
  332.                         /* Redraw empty level */
  333.                         draw_field(FALSE);
  334.                         showLocPgm(pX,pY);
  335.                         break;
  336.  
  337.                     case K_U :
  338.                     case K_u :
  339.                         save_level();
  340.                         break;
  341.  
  342.                     case K_ESC :
  343.                         end = TRUE;
  344.                         break;
  345.                         
  346.                     case K_SPACE :
  347.                         unShowLocPgm(pX,pY);
  348.                         set_cell(pY, pX, allPgms[curPgm]);
  349.                         showLocPgm(pX,pY);
  350.                         break;
  351.                         
  352.                     default :
  353.                         curchar = keyhit;
  354.                         break;
  355.                 }
  356.             }
  357.             else {
  358.                 switch (keyhit) {
  359.                     case K_PGUP :
  360.                         _setcolor(0);
  361.                         _rectangle(_GFILLINTERIOR, 570, 22+(curPgm*16),
  362.                                   580, 26+(curPgm*16));
  363.                         if (--curPgm < 0)
  364.                             curPgm = NB_EDIT_PGM - 1;
  365.                         _setcolor(15);
  366.                         _rectangle(_GFILLINTERIOR, 570, 22+(curPgm*16),
  367.                                   580, 26+(curPgm*16));
  368.                         break;
  369.  
  370.                     case K_PGDOWN :
  371.                         _setcolor(0);
  372.                         _rectangle(_GFILLINTERIOR, 570, 22+(curPgm*16),
  373.                                   580, 26+(curPgm*16));
  374.                         if (++curPgm >= NB_EDIT_PGM)
  375.                             curPgm = 0;
  376.                         _setcolor(15);
  377.                         _rectangle(_GFILLINTERIOR, 570, 22+(curPgm*16),
  378.                                   580, 26+(curPgm*16));
  379.                         break;
  380.  
  381.                     case K_LEFT :
  382.                         unsetCursor(pX,pY);
  383.                         unShowLocPgm(pX,pY);
  384.                         if (--pX < 0)
  385.                             pX = x-1;
  386.                         setCursor(pX,pY);
  387.                         showLocPgm(pX,pY);
  388.                         break;
  389.  
  390.                     case K_RIGHT :
  391.                         unsetCursor(pX,pY);
  392.                         unShowLocPgm(pX,pY);
  393.                         if (++pX >= x)
  394.                             pX = 0;
  395.                         setCursor(pX,pY);
  396.                         showLocPgm(pX,pY);
  397.                         break;
  398.  
  399.                     case K_UP :
  400.                         unsetCursor(pX,pY);
  401.                         unShowLocPgm(pX,pY);
  402.                         if (--pY < 0)
  403.                             pY = y-1;
  404.                         setCursor(pX,pY);
  405.                         showLocPgm(pX,pY);
  406.                         break;
  407.                         
  408.                     case K_DOWN :
  409.                         unShowLocPgm(pX,pY);
  410.                         unsetCursor(pX,pY);
  411.                         if (++pY >= y)
  412.                             pY = 0;
  413.                         showLocPgm(pX,pY);
  414.                         setCursor(pX,pY);
  415.                         break;
  416.                 }
  417.             }
  418.         }
  419.         unsetCursor(pX, pY);
  420.             
  421.     } 
  422.       
  423.     xend();
  424.     exit(0);
  425. }
  426.