home *** CD-ROM | disk | FTP | other *** search
/ Skunkware 5 / Skunkware 5.iso / src / Games / xblockbuster / bricks.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-05-03  |  12.1 KB  |  379 lines
  1. /*
  2.  * File:       bricks.c
  3.  * Author:     Eric Van Gestel
  4.  * Updated to X11, alternate brick support and color added by Mark S. Wedel
  5.  *
  6.  * For:                xblockbuster
  7.  */
  8. #include "xblockbuster.h"
  9. static int    has_color=FALSE;
  10.  
  11.  
  12. Pixmap     launchNW_pr,launchNW0_pr,launchNE_pr,launchNE0_pr,
  13.     solid_pr,solid0_pr,clear_pr,clear0_pr,
  14.     brick_0_pr,brick_1_pr,brick_2_pr,brick_3_pr,brick_4_pr,
  15.     brick_5_pr,brick_6_pr,brick_7_pr,brick_8_pr,brick_9_pr,
  16.     brick_a_pr,brick_b_pr,brick_c_pr,brick_d_pr,brick_e_pr,
  17.     brick_j_pr,brick_A_pr,brick_C_pr,brick_D_pr,brick_E_pr,
  18.     brick_G_pr,brick_H_pr,brick_L_pr,brick_M_pr,brick_P_pr,
  19.     brick_R_pr,brick_S_pr,brick_T_pr,brick_U_pr,brick_W_pr,
  20.     brick_X_pr;
  21.  
  22.  
  23. /* Include all the brick images */
  24. #include "icons/clear.pr"
  25. #include "icons/solid.pr"
  26. #include "icons/launchNE.pr"
  27. #include "icons/launchNW.pr"
  28. #include "icons/clear0.pr"
  29. #include "icons/solid0.pr"
  30. #include "icons/launchNE0.pr"
  31. #include "icons/launchNW0.pr"
  32. #include "icons/brick_0.pr"
  33. #include "icons/brick_1.pr"
  34. #include "icons/brick_2.pr"
  35. #include "icons/brick_3.pr"
  36. #include "icons/brick_4.pr"
  37. #include "icons/brick_5.pr"
  38. #include "icons/brick_6.pr"
  39. #include "icons/brick_7.pr"
  40. #include "icons/brick_8.pr"
  41. #include "icons/brick_9.pr"
  42. #include "icons/brick_a.pr"
  43. #include "icons/brick_b.pr"
  44. #include "icons/brick_c.pr"
  45. #include "icons/brick_d.pr"
  46. #include "icons/brick_e.pr"
  47. #include "icons/brick_j.pr"
  48. #include "icons/brick_A.pr"
  49. #include "icons/brick_C.pr"
  50. #include "icons/brick_D.pr"
  51. #include "icons/brick_E.pr"
  52. #include "icons/brick_G.pr"
  53. #include "icons/brick_H.pr"
  54. #include "icons/brick_L.pr"
  55. #include "icons/brick_M.pr"
  56. #include "icons/brick_P.pr"
  57. #include "icons/brick_R.pr"
  58. #include "icons/brick_S.pr"
  59. #include "icons/brick_T.pr"
  60. #include "icons/brick_U.pr"
  61. #include "icons/brick_W.pr"
  62. #include "icons/brick_X.pr"
  63.  
  64. /* Alternate bricks for some of the above - meant for color displays  - MSW */
  65. #include "icons/brick_a_alt.pr"
  66. #include "icons/brick_b_alt.pr"
  67. #include "icons/brick_c_alt.pr"
  68. #include "icons/brick_d_alt.pr"
  69. #include "icons/brick_e_alt.pr"
  70. #include "icons/brick_j_alt.pr"
  71. #include "icons/brick_S_alt.pr"
  72. #include "icons/brick_0_alt.pr"
  73.  
  74. /* Our Cursor */
  75. #include "icons/cursor.pr"
  76.  
  77.  
  78. void    do_brick_colors()
  79. {
  80.     Colormap    def_cmap;
  81.     XColor        exact_def;
  82.     Cursor          cursor;
  83.     Pixmap        cursor_pr;
  84.     int    count;
  85.     char        *bricks="0123456789 #/\\abcdejA^CDEGHILMPRSTUW%X";
  86.     char        option[30],*value;
  87.  
  88.     for (count=0; count<=NUM_BRICK_TYPES; count++) {
  89.         brick_color[count].bg = WhitePixel(display, screen_num);
  90.         brick_color[count].fg = BlackPixel(display, screen_num);
  91.     }
  92.  
  93.  
  94.     def_cmap = DefaultColormap(display, screen_num);
  95.  
  96.  
  97.     /* This cursor code should really be in xblockbuster.c, but
  98.     since we are dealing with colormaps here, it is easier to place
  99.     the cursor code here.  I re-color the cursor so that it does
  100.     not show up on the screen. */
  101.  
  102.     cursor_pr = XCreateBitmapFromData(display,win,cursor_bits, 
  103.         cursor_width, cursor_height);
  104.     exact_def.pixel = WhitePixel(display, screen_num);
  105.     XQueryColor(display, def_cmap, &exact_def);
  106.     cursor = XCreatePixmapCursor(display, cursor_pr, cursor_pr,
  107.         &exact_def, &exact_def, 0, 0);
  108.     XDefineCursor(display, win,cursor);
  109.  
  110.     /* Figure we need at least a 5 bit display (32 colors) in order
  111.     to support color bricks.  Probably not many 5, 6, or 7 bit displays
  112.     out there, but you never know -MSW */
  113.  
  114.     if (DefaultDepth(display,screen_num)<5) return;
  115.     else has_color=TRUE;
  116.  
  117.  
  118.     count=0;
  119.     while (bricks[count]!='\0') {
  120.         sprintf(option,"brick%c_fg",bricks[count]);
  121.         value = XGetDefault(display, "XBlockbuster", option);
  122.         if (value) {
  123.             if (!XParseColor(display, def_cmap, value, &exact_def)) {
  124.                 printf("Couldn't find color %s for option %s\n",value,option);
  125.             }
  126.             else 
  127.             if (!XAllocColor(display, def_cmap, &exact_def))
  128.                 printf("couldn't allocate color %s in option %s\n",value,option);
  129.             else
  130.                 brick_color[count].fg=exact_def.pixel;
  131.         }
  132.  
  133.         sprintf(option,"brick%c_bg",bricks[count]);
  134.         value = XGetDefault(display, "XBlockbuster", option);
  135.         if (value) {
  136.             if (!XParseColor(display, def_cmap, value, &exact_def)) {
  137.             printf("Couldn't find color %s for option %s\n",value,option);
  138.             }
  139.             else 
  140.             if (!XAllocColor(display, def_cmap, &exact_def))
  141.                 printf("couldn't allocate color %s in option %s\n",value,option);
  142.             else
  143.                 brick_color[count].bg=exact_def.pixel;
  144.         }
  145.         count++;
  146.     }
  147. }
  148.  
  149.  
  150. void bricks_init()
  151. {
  152.  
  153.     char    *value;
  154.     int    use_alt_bricks=FALSE;
  155.  
  156.     do_brick_colors();
  157.  
  158.  
  159. /* The width and height of these should really be keyed in from the defintions
  160. in the files themselves.  However, that would take a considerable amount of
  161. typing effort that I don't feel like doing.  The width and height values are
  162. hardcoded into other areas of the program anyways.  I must admit that it
  163. would be interesting to have different brick sizes, but in order to do that,
  164. it would also entail changing how the stages are stored  - MSW */
  165.  
  166.     launchNW_pr = XCreateBitmapFromData(display,win,launchNW_bits, 64,16);
  167.     launchNW0_pr = XCreateBitmapFromData(display,win,launchNW0_bits, 16,16);
  168.     launchNE_pr = XCreateBitmapFromData(display,win,launchNE_bits, 64,16);
  169.     launchNE0_pr = XCreateBitmapFromData(display,win,launchNE0_bits, 16,16);
  170.     solid_pr =   XCreateBitmapFromData(display,win,solid_bits, 64,16);
  171.     solid0_pr =  XCreateBitmapFromData(display,win,    solid0_bits, 16,16);
  172.     clear_pr =   XCreateBitmapFromData(display,win,    clear_bits, 64,16);
  173.     clear0_pr =  XCreateBitmapFromData(display,win,    clear0_bits, 16,16);
  174.     brick_1_pr = XCreateBitmapFromData(display,win,    brick_1_bits, 64,16);
  175.     brick_2_pr = XCreateBitmapFromData(display,win,    brick_2_bits, 64,16);
  176.     brick_3_pr = XCreateBitmapFromData(display,win,    brick_3_bits, 64,16);
  177.     brick_4_pr = XCreateBitmapFromData(display,win,    brick_4_bits, 64,16);
  178.     brick_5_pr = XCreateBitmapFromData(display,win,    brick_5_bits, 64,16);
  179.     brick_6_pr = XCreateBitmapFromData(display,win,    brick_6_bits, 64,16);
  180.     brick_7_pr = XCreateBitmapFromData(display,win,    brick_7_bits, 64,16);
  181.     brick_8_pr = XCreateBitmapFromData(display,win,    brick_8_bits, 64,16);
  182.     brick_9_pr = XCreateBitmapFromData(display,win,    brick_9_bits, 64,16);
  183.     brick_A_pr = XCreateBitmapFromData(display,win,    brick_A_bits, 64,16);
  184.     brick_C_pr = XCreateBitmapFromData(display,win,    brick_C_bits, 64,16);
  185.     brick_D_pr = XCreateBitmapFromData(display,win,    brick_D_bits, 64,16);
  186.     brick_E_pr = XCreateBitmapFromData(display,win,    brick_E_bits, 64,16);
  187.     brick_G_pr = XCreateBitmapFromData(display,win,    brick_G_bits, 64,16);
  188.     brick_H_pr = XCreateBitmapFromData(display,win,    brick_H_bits, 64,16);
  189.     brick_L_pr = XCreateBitmapFromData(display,win,    brick_L_bits, 64,16);
  190.     brick_M_pr = XCreateBitmapFromData(display,win,    brick_M_bits, 64,16);
  191.     brick_P_pr = XCreateBitmapFromData(display,win,    brick_P_bits, 64,16);
  192.     brick_R_pr = XCreateBitmapFromData(display,win,    brick_R_bits, 64,16);
  193.     brick_T_pr = XCreateBitmapFromData(display,win,    brick_T_bits, 64,16);
  194.     brick_U_pr = XCreateBitmapFromData(display,win,    brick_U_bits, 64,16);
  195.     brick_W_pr = XCreateBitmapFromData(display,win,    brick_W_bits, 64,16);
  196.     brick_X_pr = XCreateBitmapFromData(display,win,    brick_X_bits, 64,16);
  197.  
  198.  
  199.     /* Since everywhere else in the program uses the bitmap structures,
  200.     the use_alt_bricks only needs to be local to determine which
  201.     way to initialize the bitmap structures */
  202.  
  203.     /* See if we should use the alternate bricks */
  204.     value = XGetDefault(display, "XBlockbuster", "alternate_bricks");
  205.     if (value) {
  206.         if (strcasecmp(value,"true")==0) {
  207.             use_alt_bricks=TRUE;
  208.         }
  209.     }
  210.     /* only use the alternate bricks on a color system */
  211.     if (use_alt_bricks && has_color) {
  212.         brick_0_pr = XCreateBitmapFromData(display,win,    brick_0_alt_bits, 64,16);
  213.         brick_a_pr = XCreateBitmapFromData(display,win,    brick_a_alt_bits, 64,16);
  214.         brick_b_pr = XCreateBitmapFromData(display,win,    brick_b_alt_bits, 64,16);
  215.         brick_c_pr = XCreateBitmapFromData(display,win,    brick_c_alt_bits, 64,16);
  216.         brick_d_pr = XCreateBitmapFromData(display,win,    brick_d_alt_bits, 64,16);
  217.         brick_e_pr = XCreateBitmapFromData(display,win,    brick_e_alt_bits, 64,16);
  218.         brick_j_pr = XCreateBitmapFromData(display,win,    brick_j_alt_bits, 64,16);
  219.         brick_S_pr = XCreateBitmapFromData(display,win,    brick_S_alt_bits, 64,16);
  220.     }
  221.     else {
  222.         brick_0_pr = XCreateBitmapFromData(display,win,    brick_0_bits, 64,16);
  223.         brick_a_pr = XCreateBitmapFromData(display,win,    brick_a_bits, 64,16);
  224.         brick_b_pr = XCreateBitmapFromData(display,win,    brick_b_bits, 64,16);
  225.         brick_c_pr = XCreateBitmapFromData(display,win,    brick_c_bits, 64,16);
  226.         brick_d_pr = XCreateBitmapFromData(display,win,    brick_d_bits, 64,16);
  227.         brick_e_pr = XCreateBitmapFromData(display,win,    brick_e_bits, 64,16);
  228.         brick_j_pr = XCreateBitmapFromData(display,win,    brick_j_bits, 64,16);
  229.         brick_S_pr = XCreateBitmapFromData(display,win,    brick_S_bits, 64,16);
  230.     }
  231. }
  232.  
  233.  
  234.  
  235.  
  236. /*** address functions ***/
  237.  
  238. Pixmap        brick_addr( row, col )
  239.     int             row, col;    /* col > 0 && col < MAX_COL */
  240. {
  241.     int             tmp = stage[row][col].nhits;
  242.  
  243.     switch ( stage[row][col].code ) {
  244.     case ' ':return ( clear_pr );
  245.     case '#':return ( solid_pr );
  246.     case '/':return ( launchNE_pr );
  247.     case '\\':return ( launchNW_pr );
  248.  
  249.     case '9':if ( !tmp-- )    return ( brick_9_pr );
  250.     case '8':if ( !tmp-- )    return ( brick_8_pr );
  251.     case '7':if ( !tmp-- )    return ( brick_7_pr );
  252.     case '6':if ( !tmp-- )    return ( brick_6_pr );
  253.     case '5':if ( !tmp-- )    return ( brick_5_pr );
  254.     case '4':if ( !tmp-- )    return ( brick_4_pr );
  255.     case '3':if ( !tmp-- )    return ( brick_3_pr );
  256.     case '2':if ( !tmp-- )    return ( brick_2_pr );
  257.     case '1':return ( brick_1_pr );
  258.     case '0':return ( brick_0_pr );
  259.     case 'a':return ( brick_a_pr );
  260.     case 'b':return ( brick_b_pr );
  261.     case 'c':return ( brick_c_pr );
  262.     case 'd':return ( brick_d_pr );
  263.     case 'e':return ( brick_e_pr );
  264.     case 'j':return ( brick_j_pr );
  265.     case 'A':return ( brick_A_pr );
  266.     case '^':return ( solid_pr );
  267.     case 'C':return ( brick_C_pr );
  268.     case 'D':return ( brick_D_pr );
  269.     case 'E':return ( brick_E_pr );
  270.     case 'G':return ( brick_G_pr );
  271.     case 'H':return ( brick_H_pr );
  272.     case 'I':return ( clear_pr );
  273.     case 'L':return ( brick_L_pr );
  274.     case 'M':return ( brick_M_pr );
  275.     case 'P':return ( brick_P_pr );
  276.     case 'R':return ( brick_R_pr );
  277.     case 'S':return ( brick_S_pr );
  278.     case 'T':return ( brick_T_pr );
  279.     case 'U':return ( brick_U_pr );
  280.     case 'W':return ( brick_W_pr );
  281.     case '%':return ( solid_pr );
  282.     case 'X':return ( brick_X_pr );
  283.  
  284.     default:
  285.         perror( "Illegal map code" );
  286.         exit( 1 );
  287.     }
  288. }
  289.  
  290. Pixmap        brick_addr0( row, col )
  291.     int             row, col;    /* col == 0 || col == MAX_COL */
  292. {
  293.     switch ( stage[row][col].code ) {
  294.     case ' ':return ( clear0_pr );
  295.     case '#':return ( solid0_pr );
  296.     case '/':return ( launchNE0_pr );
  297.     case '\\':return ( launchNW0_pr );
  298.  
  299.     default:
  300.         perror( "Illegal map code" );
  301.         exit( 1 );
  302.     };
  303. }
  304.  
  305.  
  306.  
  307. int        brick_value( row,col )
  308. int             row, col;    /* col > 0 && col < MAX_COL */
  309. {
  310.  
  311.     switch ( stage[row][col].code ) {
  312.  
  313.     case '0':return(0);
  314.     case '1':return(1);
  315.     case '2':return(2-stage[row][col].nhits);
  316.     case '3':return(3-stage[row][col].nhits);
  317.     case '4':return(4-stage[row][col].nhits);
  318.     case '5':return(5-stage[row][col].nhits);
  319.     case '6':return(6-stage[row][col].nhits);
  320.     case '7':return(7-stage[row][col].nhits);
  321.     case '8':return(8-stage[row][col].nhits);
  322.     case '9':return(9-stage[row][col].nhits);
  323.     case ' ':return(10);
  324.     case '#':return(11);
  325.     case '/':return(12);
  326.     case '\\':return(13);
  327.     case 'a':return(14); 
  328.     case 'b':return(15);
  329.     case 'c':return(16);
  330.     case 'd':return(17);
  331.     case 'e':return(18);
  332.     case 'j':return(19);
  333.     case 'A':return(20);
  334.     case '^':return(21);
  335.     case 'C':return(22);
  336.     case 'D':return(23);
  337.     case 'E':return(24);
  338.     case 'G':return(25);
  339.     case 'H':return(26);
  340.     case 'I':return(27);
  341.     case 'L':return(28);
  342.     case 'M':return(29);
  343.     case 'P':return(30);
  344.     case 'R':return(31);
  345.     case 'S':return(32);
  346.     case 'T':return(33);
  347.     case 'U':return(34);
  348.     case 'W':return(35);
  349.     case '%':return(36);
  350.     case 'X':return(37);
  351.  
  352.     default:
  353.         perror( "Illegal map code" );
  354.         exit( 1 );
  355.     }
  356. }
  357.  
  358.  
  359.  
  360.  
  361. void draw_brick( row, col ) 
  362. int row, col;
  363. {
  364.     if (has_color) {
  365.         XSetForeground(display, gc_color, brick_color[brick_value(row,col)].fg); 
  366.         XSetBackground(display, gc_color, brick_color[brick_value(row,col)].bg);
  367.     }
  368.     XCopyPlane(display, brick_addr(row,col), win, gc_color, 0, 0, 
  369.         64, 16, COL_X(col), ROW_Y(row), 1);
  370.  
  371. }
  372.  
  373. void draw_brick0( row, col )
  374. int row, col;
  375. {
  376.     XCopyPlane(display, brick_addr0(row,col), win, gc, 0, 0,
  377.         16, 16, COL_X(col), ROW_Y(row), 1);
  378. }
  379.