home *** CD-ROM | disk | FTP | other *** search
/ ISV Strong Games / ISV_STRONG_GAMES.iso / desktop / polysaw / !PolySaw / source / c / edit < prev    next >
Text File  |  1990-07-30  |  6KB  |  288 lines
  1. /* functions called in response to button presses in edit modes */
  2.  
  3.  
  4. #include "wimp.h"
  5. #include "wimpt.h"
  6. #include "win.h"
  7. #include "event.h"
  8. #include "baricon.h"
  9. #include "res.h"
  10. #include "resspr.h"
  11. #include "menu.h"
  12. #include "template.h"
  13. #include "dbox.h"
  14. #include "werr.h"
  15. #include "bbc.h" 
  16. #include "coords.h" 
  17.  
  18. #include <math.h>
  19. #include <stdlib.h>
  20.  
  21. #include "polysaw.h"
  22.  
  23.  
  24.  
  25.  
  26. #define FF_BIT 128    /* (in grid[][]).  For 'flood-fill' calculation 
  27.                          when joining squares */
  28.  
  29. static coords_pointstr poly[MAX_SQUARES]; /* for list of such squares */
  30.  
  31. /*****************  FUNCTIONS **********************************/
  32.  
  33. static void    join_up_squares(int row, int col);
  34. static int     do_a_neighbour(int r, int c, int ns);
  35.  
  36.  
  37.  
  38.  
  39. void deal_with_squares_but(coords_pointstr wrk, wimp_bbits mse_b)
  40. {
  41. int x, y, g, row, col;
  42.  
  43.  
  44. if (wimp_BLEFT & mse_b)
  45.   {                             
  46.   x = roundtonearest(wrk.x - HS, 2*HS);
  47.   y = roundtonearest(wrk.y - HS, 2*HS);
  48.   /* x,y is bottom left of square */
  49.   row = (-y-2*HS)/(2*HS);
  50.   col = x/(2*HS);
  51.   if (col<0 || row<0 || col>=MAX_BOARD || row>=MAX_BOARD)
  52.        return;
  53.   g = (int) grid[row][col];
  54.   if ( g & (SQUARE_BIT | PIECE_BIT) ) 
  55.        return;   
  56.         
  57.   grid[row][col]  |=  SQUARE_BIT;
  58.  
  59.   force_grid_redraw(row, col);  
  60.   }
  61.  
  62. if (wimp_BRIGHT & mse_b)
  63.   {                             
  64.   x = roundtonearest(wrk.x - HS, 2*HS);
  65.   y = roundtonearest(wrk.y - HS, 2*HS);
  66.   /* x,y is bottom left of square */
  67.   row = (-y-2*HS)/(2*HS);
  68.   col = x/(2*HS);
  69.   if (col<0 || row<0 || col>=MAX_BOARD || row>=MAX_BOARD)
  70.        return;
  71.   g = (int) grid[row][col];
  72.   if ( g & SQUARE_BIT) 
  73.     {
  74.     grid[row][col]  &=  ~SQUARE_BIT;
  75.     force_grid_redraw(row, col);  
  76.     }
  77.   } 
  78.  
  79. }
  80.  
  81.  
  82.  
  83. void deal_with_holes_but(coords_pointstr wrk, wimp_bbits mse_b)
  84. {
  85. int x, y, g, row, col;
  86.  
  87.  
  88. if (wimp_BLEFT & mse_b)
  89.   {                             
  90.   x = roundtonearest(wrk.x - HS, 2*HS);
  91.   y = roundtonearest(wrk.y - HS, 2*HS);
  92.   /* x,y is bottom left of hole */
  93.   row = (-y-2*HS)/(2*HS);
  94.   col = x/(2*HS);
  95.   if (col<0 || row<0 || col>=MAX_BOARD || row>=MAX_BOARD)
  96.        return;
  97.   g = (int) grid[row][col];
  98.   if ( g & (HOLE_BIT | SQUARE_BIT | PIECE_BIT) ) 
  99.        return;   
  100.         
  101.   grid[row][col]  |=  HOLE_BIT;
  102.  
  103.   force_grid_redraw(row, col); 
  104.   
  105.   }
  106.  
  107. if (wimp_BRIGHT & mse_b)
  108.   {                             
  109.   x = roundtonearest(wrk.x - HS, 2*HS);
  110.   y = roundtonearest(wrk.y - HS, 2*HS);
  111.   /* x,y is bottom left of hole */
  112.   row = (-y-2*HS)/(2*HS);
  113.   col = x/(2*HS);
  114.   if (col<0 || row<0 || col>=MAX_BOARD || row>=MAX_BOARD)
  115.        return;
  116.   g = (int) grid[row][col];
  117.   if ( (g & (HOLE_BIT | SQUARE_BIT | PIECE_BIT)) == HOLE_BIT) 
  118.     { 
  119.     grid[row][col]  &=  ~HOLE_BIT;
  120.     force_grid_redraw(row, col); 
  121.     }
  122.   }
  123.  
  124. }
  125.  
  126.  
  127.  
  128. void deal_with_jnsplt_but(coords_pointstr wrk, wimp_bbits mse_b)
  129. {
  130. int i, p, dead, x, y;
  131.  
  132.  
  133. if (mse_b & wimp_BLEFT)
  134.   {
  135.    join_up_squares((-wrk.y)/(2*HS), wrk.x/(2*HS));
  136.   }
  137. if (mse_b & wimp_BRIGHT)
  138.   {
  139.   dead = which_piece(wrk);
  140.   if (dead > MAX_PIECES)
  141.       return;
  142.   /* update grid */
  143.   for (i=0; i<piece[dead].nofunits; i++)
  144.     {
  145.     x = piece[dead].cog.x + piece[dead].units[i].x;
  146.     y = piece[dead].cog.y + piece[dead].units[i].y;
  147.     grid[(-y-HS)/(2*HS)][(x-HS)/(2*HS)] &= ~PIECE_BIT;
  148.     }
  149.   force_piece_redraw(dead);
  150.  
  151.   /* shuffle down the existing polys to fill gap */
  152.  
  153.   for (p=dead; p<nofpieces-1; p++)
  154.     {
  155.     piece[p] = piece[p+1];
  156.     }
  157.   nofpieces -= 1;
  158.   
  159.  
  160.   }
  161. }
  162.  
  163.  
  164.  
  165.  
  166.  
  167. int do_a_neighbour(int r, int c, int ns)
  168. {
  169. int g;
  170.  
  171. if (r<0 || c<0 || r>=MAX_BOARD || c>=MAX_BOARD) return ns;
  172.  
  173. g = grid[r][c];
  174. if ( (g & SQUARE_BIT)  &&  !(g & FF_BIT) ) 
  175.   {
  176.   poly[ns].y = r;
  177.   poly[ns].x = c;
  178.   ns += 1;
  179.   grid[r][c]  |= FF_BIT;
  180.   }
  181. return ns;
  182. }
  183.  
  184.  
  185.  
  186. void join_up_squares(int row, int col)
  187.  
  188. /* passed grid posn to start from.  does a flood fill from row, col
  189. using   (grid[][] & SQUARE_BIT)  values */
  190.  
  191. {
  192. int cogx=0, cogy=0;
  193. int nofs=1, next=0, i;
  194.  
  195. if (nofpieces == MAX_PIECES)
  196.   {
  197.   werr(FALSE, "Too many polyonimoes\n");
  198.   return;
  199.   }
  200.  
  201. if (!(grid[row][col] & SQUARE_BIT))
  202.     return;
  203.  
  204. poly[0].y = row;
  205. poly[0].x = col;
  206. grid[row][col] |= FF_BIT;
  207.  
  208. while (next < nofs)
  209.   {
  210.   nofs = do_a_neighbour(poly[next].y, poly[next].x - 1, nofs);
  211.   nofs = do_a_neighbour(poly[next].y, poly[next].x + 1, nofs);
  212.   nofs = do_a_neighbour(poly[next].y - 1, poly[next].x, nofs);
  213.   nofs = do_a_neighbour(poly[next].y + 1, poly[next].x, nofs);
  214.   next ++;
  215.   }
  216.  
  217. /* clear all FF_BITs for next time */
  218. for (i=0; i<nofs; i++)
  219.   {
  220.   grid[poly[i].y][poly[i].x] &= ~FF_BIT;
  221.   }
  222.  
  223. if (nofs > MAX_SQUARES)
  224.   {
  225.   werr(FALSE, "Poly too big\n");
  226.   return;
  227.   }
  228.  
  229.  
  230. /* now we're committed to actually making the thing. First clear squares. */
  231.  
  232. for (i=0; i<nofs; i++)
  233.   {
  234.   grid[poly[i].y][poly[i].x] &= ~SQUARE_BIT;
  235.   }
  236.  
  237.  
  238. /* turn into work area units */
  239. for (i=0; i<nofs; i++)
  240.   {
  241.   poly[i].y *= 2*HS;
  242.   poly[i].y = -HS - poly[i].y;
  243.   poly[i].x *= 2*HS;
  244.   poly[i].x += HS;
  245.   /* these are now centres of squares in work coords */
  246.   }
  247.  
  248. /* find cog */
  249. for (i=0; i<nofs; i++)
  250.   {
  251.   cogx += poly[i].x;
  252.   cogy += poly[i].y;
  253.   }
  254. cogx = cogx/nofs;
  255. cogy = cogy/nofs;
  256. cogx = roundtonearest(cogx, HS);
  257. cogy = roundtonearest(cogy, HS);
  258.  
  259. /* start filling in info, getting square centres rel. to cog */
  260. piece[nofpieces].cog.x = cogx;
  261. piece[nofpieces].cog.y = cogy;
  262.  
  263. piece[nofpieces].nofunits = nofs;
  264. for (i=0; i<nofs; i++)
  265.   {
  266.   piece[nofpieces].units[i].x = poly[i].x - cogx;
  267.   piece[nofpieces].units[i].y = poly[i].y - cogy;
  268.   }
  269.  
  270. /* now at stage like just after reading in a file */
  271. fill_out_polydefn(nofpieces);
  272.  
  273. /* finally draw the new piece and update number of pieces*/
  274. force_piece_redraw(nofpieces);
  275. nofpieces += 1;
  276. }
  277.  
  278.  
  279.  
  280.  
  281.  
  282.  
  283.  
  284.  
  285.  
  286.  
  287.  
  288.