home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 October / usenetsourcesnewsgroupsinfomagicoctober1994disk2.iso / games / volume11 / pc-xbd / part02 / bitmap.c next >
C/C++ Source or Header  |  1990-12-17  |  8KB  |  401 lines
  1. /*********************************************/
  2. /*                                           */
  3. /*      Editor for all bitmaps                */
  4. /*                                           */
  5. /*      PC-VGA version from :                */
  6. /*                                           */
  7. /*        Herve SOULARD, Paris, 1990        */
  8. /*                                           */
  9. /*********************************************/
  10.  
  11. #include <stdio.h>
  12. #include <malloc.h>
  13. #include <graph.h>
  14.  
  15. #define    X_OFF    100
  16. #define    Y_OFF    100
  17.  
  18. #define    X_SIZE    10
  19. #define    Y_SIZE    10
  20.  
  21. #define    WIDTH        16
  22. #define    HEIGHT    16
  23.  
  24. #define    MAXPGM    23
  25.  
  26. struct videoconfig config;
  27. int sizePgm;
  28.  
  29. char *pgms[MAXPGM];
  30. char *bitmap[MAXPGM];
  31. char *name[MAXPGM];
  32.  
  33.  
  34. void makePgm(char bitmap[],char pgms[])
  35. {
  36.     char *ptr,c;
  37.     int i,j;
  38.     unsigned r1,r2,r3,r4;
  39.     unsigned *uptr;
  40.     
  41.     ptr = pgms;
  42.     uptr = (unsigned *)pgms;
  43.     
  44.     if (ptr == NULL) {
  45.         printf ("Erreur allocation (pgms)\n");
  46.         exit(1);
  47.     }    
  48.  
  49.     *ptr = WIDTH;
  50.     *(ptr+2) = HEIGHT;
  51.     *(ptr+1) = *(ptr+3) = 0;
  52.  
  53.     for (i=0; i < HEIGHT;i++) {
  54.         r1 = r2 = r3 = r4 = 0;
  55.         for (j=0; j < WIDTH; j++) {
  56.             c = bitmap[(i*WIDTH)+j];
  57.             if (c & 0x01)
  58.                 r1 |= (1 << ((WIDTH-1)-j));
  59.             if (c & 0x02)
  60.                 r2 |= (1 << ((WIDTH-1)-j));
  61.             if (c & 0x04)
  62.                 r3 |= (1 << ((WIDTH-1)-j));
  63.             if (c & 0x08)
  64.                 r4 |= (1 << ((WIDTH-1)-j));
  65.         }
  66.         /*
  67.             For compatibility with _putimage from Microsoft
  68.             
  69.         *(uptr+2+(i*4)) = r1;
  70.         *(uptr+2+(i*4)+1) = r2;
  71.         *(uptr+2+(i*4)+2) = r3;
  72.         *(uptr+2+(i*4)+3) = r4;
  73.         */
  74.  
  75.         /*    Using my own _putimage (drawPgm)
  76.         */
  77.         *(uptr+2+i) = r1;
  78.         *(uptr+2+i+16) = r2;
  79.         *(uptr+2+i+32) = r3;
  80.         *(uptr+2+i+48) = r4;
  81.     }
  82.     for (i=4; i< sizePgm; i+=2) {
  83.         c = *(ptr+i);
  84.         *(ptr+i) = *(ptr+i+1);
  85.         *(ptr+i+1) = c;
  86.     }
  87. }
  88.  
  89.  
  90. void makePgms()
  91. {
  92.     int i;
  93.     
  94.     for (i = 0; i < MAXPGM;i++) {
  95.         pgms[i] = (char *)malloc(sizePgm);
  96.         makePgm(bitmap[i],pgms[i]);
  97.     }
  98. }
  99.  
  100. void drawBitmap(int num)
  101. {
  102.     char c;
  103.     int i,j;
  104.     int x,y;
  105.     char *ptrBitmap;
  106.  
  107.     
  108.     ptrBitmap = bitmap[num];
  109.     makePgm(ptrBitmap,pgms[num]);
  110.     
  111.     drawPgm(num * 3,8,pgms[num],_GPSET);
  112.  
  113.     _settextposition(3,0);
  114.     _outtext("                                                                               ");
  115.     _settextposition(3,1 + (num * 3));
  116.     _outtext("^");
  117.     
  118.     _settextposition(5,50);
  119.     _outtext("                    ");
  120.     _settextposition(5,50);
  121.     _outtext(name[num]);
  122.     
  123.     for (i=0; i < HEIGHT;i++) {
  124.         y = (i*(Y_SIZE+2)) + Y_OFF;
  125.         for (j=0; j < WIDTH; j++) {
  126.             c = ptrBitmap[(i*WIDTH)+j];
  127.             _setcolor(c);
  128.             x = (j*(X_SIZE+2)) + X_OFF;
  129.             _rectangle(_GFILLINTERIOR, x, y, x + X_SIZE, y + Y_SIZE);
  130.         }
  131.     }
  132. }
  133.  
  134.  
  135. void drawColor()
  136. {
  137.     int i;
  138.     int y;
  139.     
  140.     for (i=0;i<16;i++) {
  141.         _setcolor(i);
  142.         y = Y_OFF + (i*2*Y_SIZE);
  143.         _rectangle(_GFILLINTERIOR, 450, y + 5,
  144.             450 + 2 * X_SIZE, y + 2 * Y_SIZE);
  145.     }
  146. }
  147.  
  148. void setCursor(xC,yC,bitmap)
  149. int xC,yC;
  150. char bitmap[];
  151. {
  152.     char *ptr,c;
  153.     int x,y;
  154.  
  155.     c = bitmap[(yC*WIDTH)+xC];
  156.     _setcolor(15 - c);
  157.     y = (yC*(Y_SIZE+2)) + Y_OFF;
  158.     x = (xC*(X_SIZE+2)) + X_OFF;
  159.     _rectangle(_GBORDER, x, y, x + X_SIZE, y + Y_SIZE);
  160. }
  161.  
  162.  
  163. void unsetCursor(xC,yC,bitmap)
  164. int xC,yC;
  165. char bitmap[];
  166. {
  167.     char *ptr,c;
  168.     int x,y;
  169.  
  170.     c = bitmap[(yC*WIDTH)+xC];
  171.     _setcolor(c);
  172.     y = (yC*(Y_SIZE+2)) + Y_OFF;
  173.     x = (xC*(X_SIZE+2)) + X_OFF;
  174.     _rectangle(_GBORDER, x, y, x + X_SIZE, y + Y_SIZE);
  175. }
  176.  
  177. void setColor(xC,yC,bitmap)
  178. int xC,yC;
  179. char bitmap[];
  180. {
  181.     char c;
  182.     int aux;
  183.  
  184.     c = bitmap[(yC*WIDTH)+xC];
  185.     _setcolor(c);
  186.     aux = Y_OFF + (c*2*Y_SIZE);
  187.     _rectangle(_GFILLINTERIOR, 480, aux + 5, 480+ 2*X_SIZE, aux + 2*Y_SIZE);
  188. }
  189.  
  190.  
  191. void unsetColor(xC,yC,bitmap)
  192. int xC,yC;
  193. char bitmap[];
  194. {
  195.     char c;
  196.     int aux;
  197.  
  198.     c = bitmap[(yC*WIDTH)+xC];
  199.     _setcolor(0);
  200.     aux = Y_OFF + (c*2*Y_SIZE);
  201.     _rectangle(_GFILLINTERIOR, 480, aux + 5, 480+ 2*X_SIZE, aux + 2*Y_SIZE);
  202. }
  203.  
  204. void load()
  205. {
  206.     FILE *map;
  207.     int i,j,k;
  208.     char buf[300];
  209.     int *ptr;
  210.     char *aux;
  211.     int color[WIDTH];
  212.     
  213.     strcpy(buf,"bitmaps.dat");
  214.     map = fopen(buf,"r");
  215.     if (map == 0) {
  216.         printf("Erreur d'ouverture du fichier\n");
  217.     }
  218.     else {
  219.         for (i = 0;i < MAXPGM;i++) {
  220.             fgets(buf,300,map);
  221.             bitmap[i] = (char *)malloc(HEIGHT * WIDTH);
  222.             name[i] = (char *)malloc(80);
  223.             sscanf(buf,"%s",name[i]);
  224.             for (j = 0;j < HEIGHT;j++) {
  225.                 ptr = color;
  226.                 fgets(buf,300,map);
  227.                 sscanf(buf,"%d %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d",
  228.                         ptr++,ptr++,ptr++,ptr++,ptr++,ptr++,ptr++,ptr++,ptr++,
  229.                          ptr++,ptr++,ptr++,ptr++,ptr++,ptr++,ptr);
  230.                 for (k = 0; k < WIDTH;k++)
  231.                     bitmap[i][(j*WIDTH)+k] = (char)color[k];
  232.             }
  233.             fgets(buf,300,map);
  234.  
  235.         }
  236.         fclose(map);
  237.     }
  238. }
  239.  
  240. void save()
  241. {
  242.     FILE *map;
  243.     char filename[20];
  244.     int i,j,k;
  245.     
  246.     strcpy(filename,"bitmaps.dat");
  247.     map = fopen(filename,"w");
  248.     if (map == 0) {
  249.         printf("Erreur d'ouverture du fichier\n");
  250.     }
  251.     else {
  252.         for (i = 0;i < MAXPGM;i++) {
  253.             fprintf(map,"%s %2d\n",name[i],i);
  254.             for (j = 0;j < HEIGHT;j++) {
  255.                 fprintf(map,"\t");
  256.                 for (k = 0;k < WIDTH;k++) 
  257.                     fprintf(map,"%2d ",bitmap[i][(j*WIDTH)+k]);
  258.                 fprintf(map,"\n");
  259.             }
  260.             fprintf(map,"\t\n");
  261.         }
  262.         fclose(map);
  263.     }
  264. }
  265.  
  266.  
  267. main()
  268. {
  269.     int fin = 0;
  270.     char keyhit;
  271.     int num = 0;
  272.     int x = 0;
  273.     int y = 0;
  274.     int color = 15;
  275.     int aux;
  276.     
  277.     _setvideomode(_MAXRESMODE);
  278.     _getvideoconfig(&config);
  279.     sizePgm = (unsigned int)_imagesize(0,0,WIDTH-1,HEIGHT-1);
  280.  
  281.     load();
  282.     makePgms();
  283.     
  284.     for (aux=0;aux < MAXPGM; aux++)
  285.         drawPgm(aux * 3,8,pgms[aux],_GPSET);
  286.  
  287.     drawBitmap(num);
  288.  
  289.     drawColor();
  290.     
  291.     _setcolor(color);
  292.     aux = Y_OFF + (color*2*Y_SIZE);
  293.     _rectangle(_GFILLINTERIOR, 420, aux + 5, 420+ 2*X_SIZE, aux + 2*Y_SIZE);
  294.  
  295.     while (!fin) {
  296.         setCursor(x,y,bitmap[num]);
  297.         if (kbhit()) {
  298.             keyhit = getch();
  299.             if (keyhit == 0 || keyhit == 0xE0)
  300.                 keyhit = getch();
  301.             switch (keyhit) {
  302.                 case 32 :
  303.                     unsetColor(x,y,bitmap[num]);
  304.                     bitmap[num][(y*16)+x] = color;
  305.                     drawBitmap(num);
  306.                     setColor(x,y,bitmap[num]);
  307.                     break;
  308.                 case 75 :
  309.                     unsetCursor(x,y,bitmap[num]);
  310.                     unsetColor(x,y,bitmap[num]);
  311.                     if (--x < 0)
  312.                         x = WIDTH-1;
  313.                     setCursor(x,y,bitmap[num]);
  314.                     setColor(x,y,bitmap[num]);
  315.                     break;
  316.                 case 72 :
  317.                     unsetCursor(x,y,bitmap[num]);
  318.                     unsetColor(x,y,bitmap[num]);
  319.                     if (--y < 0)
  320.                         y = HEIGHT-1;
  321.                     setCursor(x,y,bitmap[num]);
  322.                     setColor(x,y,bitmap[num]);
  323.                     break;
  324.                 case 80 :
  325.                     unsetCursor(x,y,bitmap[num]);
  326.                     unsetColor(x,y,bitmap[num]);
  327.                     if (++y > HEIGHT-1)
  328.                         y = 0;
  329.                     setCursor(x,y,bitmap[num]);
  330.                     setColor(x,y,bitmap[num]);
  331.                     break;
  332.                 case 77 :
  333.                     unsetCursor(x,y,bitmap[num]);
  334.                     unsetColor(x,y,bitmap[num]);
  335.                     if (++x > WIDTH-1)
  336.                         x = 0;
  337.                     setCursor(x,y,bitmap[num]);
  338.                     setColor(x,y,bitmap[num]);
  339.                     break;
  340.                 case 73 :
  341.                     unsetCursor(x,y,bitmap[num]);
  342.                     unsetColor(x,y,bitmap[num]);
  343.                     x = y = 0;
  344.                     if (++num > MAXPGM-1)
  345.                         num = 0;
  346.                     drawBitmap(num);
  347.                     setCursor(x,y,bitmap[num]);
  348.                     setColor(x,y,bitmap[num]);
  349.                     break;
  350.                 case 81 :
  351.                     unsetCursor(x,y,bitmap[num]);
  352.                     unsetColor(x,y,bitmap[num]);
  353.                     x = y = 0;
  354.                     if (--num < 0)
  355.                         num = MAXPGM-1;
  356.                     drawBitmap(num);
  357.                     setCursor(x,y,bitmap[num]);
  358.                     setColor(x,y,bitmap[num]);
  359.                     break;
  360.                 case 'S' :
  361.                 case 's' :
  362.                     save();
  363.                     break;
  364.                 case '+' :
  365.                     _setcolor(0);
  366.                     aux = Y_OFF + (color*2*Y_SIZE);
  367.                     _rectangle(_GFILLINTERIOR, 420, aux + 5, 
  368.                               420+ 2*X_SIZE, aux + 2*Y_SIZE);
  369.                     if (++color > 15)
  370.                         color = 0;
  371.                     _setcolor(color);
  372.                     aux = Y_OFF + (color*2*Y_SIZE);
  373.                     _rectangle(_GFILLINTERIOR, 420, aux + 5, 
  374.                               420+ 2*X_SIZE, aux + 2*Y_SIZE);
  375.  
  376.                     break;
  377.                 case '-' :
  378.                     _setcolor(0);
  379.                     aux = Y_OFF + (color*2*Y_SIZE);
  380.                     _rectangle(_GFILLINTERIOR, 420, aux + 5, 
  381.                               420+ 2*X_SIZE, aux + 2*Y_SIZE);
  382.                     if (--color < 0)
  383.                         color = 15;
  384.                     _setcolor(color);
  385.                     aux = Y_OFF + (color*2*Y_SIZE);
  386.                     _rectangle(_GFILLINTERIOR, 420, aux + 5, 
  387.                               420+ 2*X_SIZE, aux + 2*Y_SIZE);
  388.                     break;
  389.                 case 27 :
  390.                     fin = 1;
  391.                     break;
  392.             }
  393.         }
  394.         unsetCursor(x,y,bitmap[num]);
  395.     }
  396.     
  397.     _setvideomode(_DEFAULTMODE);
  398.     exit(0);
  399. }
  400.  
  401.