home *** CD-ROM | disk | FTP | other *** search
/ ISV Strong Games / ISV_STRONG_GAMES.iso / desktop / polysaw / !PolySaw / source / c / misc < prev    next >
Text File  |  1990-07-23  |  4KB  |  183 lines

  1. #include "wimp.h"
  2. #include "wimpt.h"
  3. #include "werr.h"
  4. #include "coords.h"
  5.  
  6. #include <stdlib.h>
  7.  
  8. #include "polysaw.h"
  9.  
  10.  
  11. #define ONE (1<<12)
  12.  
  13. int integer_sqrt(int x)
  14. {             
  15. int y,z,a,b,i,n,y2;
  16. static int g[5] = {8192, 5793, 4871, 4467, 4277};
  17.  
  18. if (x==0) return 0;
  19. n=0;
  20. while (x < ONE)    {n--;     x = x << 2;}
  21. while (x >= 4*ONE) {n++;     x = x >> 2;}
  22.  
  23. z = ONE;
  24. a = ONE;
  25. i = 0;
  26. while ( a < x  &&  i < 4 )
  27.     {
  28.     while ((b = (a*g[i])/ONE) > x  &&  i < 4)    i++;
  29.     if (i < 4)
  30.         {
  31.         a = b;
  32.         z = (z*g[i+1])/ONE;
  33.         }
  34.     }
  35.  
  36. y = (x*ONE)/a - ONE;
  37. y2 = (y*y)/ONE;
  38. z = (  z*( ONE + (y/2) - (y2/8) + ((y*y2)/(ONE*16)) )  ) >> 6;
  39. z = (n < 0) ? z>>(-n) : z<<n;
  40. return z/ONE;
  41. }
  42.  
  43.  
  44. int roundtonearest(int a, int step)
  45. {
  46. if (step == 0) werr(TRUE, "roundtonearest got a 0\n");
  47. step = abs(step);
  48. if (a >= 0) 
  49.   return  step*( ( a+step/2) / step);
  50. else
  51.   return -step*( (-a+step/2) / step);
  52. }
  53.  
  54.  
  55. void fill_out_polydefn(int p)
  56. {
  57. int i, x0, x1, y0, y1, maxrad, x, y;
  58.  
  59.  
  60.  
  61. /* find a bounding box. used for finding which piece clicked on
  62. and for redraw.  also calc radius at which spin turns into move */
  63.  
  64. x0 = piece[p].units[0].x - HS;
  65. y0 = piece[p].units[0].y - HS;
  66. x1 = x0 + 2*HS;
  67. y1 = y0 + 2*HS;
  68. for (i=0; i < piece[p].nofunits; i++)
  69.   {
  70.   if (piece[p].units[i].x - HS  <  x0)   x0 = piece[p].units[i].x - HS;
  71.   if (piece[p].units[i].y - HS  <  y0)   y0 = piece[p].units[i].y - HS;
  72.   if (piece[p].units[i].x + HS  >  x1)   x1 = piece[p].units[i].x + HS;
  73.   if (piece[p].units[i].y + HS  >  y1)   y1 = piece[p].units[i].y + HS;
  74.   }
  75. piece[p].movespin_rad = (x1-x0+y1-y0)*(x1-x0+y1-y0)/32;
  76. maxrad = abs(x0);
  77. if (maxrad < abs(x1)) maxrad = abs(x1);
  78. if (maxrad < abs(y0)) maxrad = abs(y0);
  79. if (maxrad < abs(y1)) maxrad = abs(y1);
  80.  
  81. piece[p].box.x0 = -maxrad;
  82. piece[p].box.y0 = -maxrad;
  83. piece[p].box.x1 =  maxrad;
  84. piece[p].box.y1 =  maxrad;
  85.  
  86. /* initiallise the orientation and parity info */ 
  87. piece[p].rotflipstate = 0;
  88.  
  89. /* associate units with sprites according to existence of
  90.    neighbouring units */
  91.  
  92. for (i=0; i<piece[p].nofunits; i++)
  93.   {
  94.   int s=15, j;
  95.   for (j=0; j<piece[p].nofunits; j++)
  96.      {
  97.      if (piece[p].units[j].x == piece[p].units[i].x)
  98.          {
  99.          if (piece[p].units[j].y == piece[p].units[i].y + 2*HS)
  100.              s = s &~ 1;
  101.          if (piece[p].units[j].y == piece[p].units[i].y - 2*HS)
  102.              s = s &~ 4;
  103.          }
  104.      if (piece[p].units[j].y == piece[p].units[i].y)
  105.          {
  106.          if (piece[p].units[j].x == piece[p].units[i].x - 2*HS)
  107.              s = s &~ 2;
  108.          if (piece[p].units[j].x == piece[p].units[i].x + 2*HS)
  109.              s = s &~ 8;
  110.          }
  111.       }
  112.       piece[p].unitpic[i] = s;
  113.   }
  114.  
  115. /* fill in grid  - 
  116. formula is (x,y) goes to   grid[(-y-HS)/(2*HS)][(x-HS)/(2*HS)]   
  117. this is centre of squares to   row, column */
  118.  
  119. for (i=0; i < piece[p].nofunits; i++)
  120.   {
  121.   x = piece[p].cog.x + piece[p].units[i].x;
  122.   y = piece[p].cog.y + piece[p].units[i].y;
  123.   grid[(-y-HS)/(2*HS)][(x-HS)/(2*HS)] |= PIECE_BIT;
  124.   }
  125.  
  126. }
  127.  
  128.  
  129. int which_piece(coords_pointstr w)
  130. {
  131. int p, i;
  132. coords_pointstr pt;
  133.  
  134. for (p=0; p < nofpieces; p++)
  135.   {
  136.   pt.x = w.x - piece[p].cog.x;
  137.   pt.y = w.y - piece[p].cog.y;
  138.   /* pt is offset to centre of piece, as all piece info is rel. cog */
  139.   if ( coords_withinbox(&pt, &piece[p].box) )   
  140.      {
  141.      for (i=0; i < piece[p].nofunits; i++)
  142.         {
  143.         if ( abs(pt.x - piece[p].units[i].x) <= HS   &&   
  144.              abs(pt.y - piece[p].units[i].y) <= HS )   
  145.              {
  146.              return p;
  147.              }
  148.         }
  149.      }
  150.   }
  151. return MAX_PIECES+1;
  152. }
  153.  
  154.  
  155.  
  156. void force_grid_redraw(int row, int col)
  157. {
  158. wimp_redrawstr r;
  159.  
  160. r.w = board_wh;
  161. r.box.x0 = 2*HS*col;
  162. r.box.y0 = 2*HS*(-row-1);
  163. r.box.x1 = r.box.x0 + 2*HS;
  164. r.box.y1 = r.box.y0 + 2*HS;
  165.  
  166. wimpt_noerr(wimp_force_redraw(&r));
  167. }
  168.  
  169.  
  170. void force_piece_redraw(int p)
  171. {
  172. wimp_redrawstr r;
  173.  
  174. r.w = board_wh;
  175. r.box.x0 = piece[p].cog.x + piece[p].box.x0;
  176. r.box.y0 = piece[p].cog.y + piece[p].box.y0;
  177. r.box.x1 = piece[p].cog.x + piece[p].box.x1;
  178. r.box.y1 = piece[p].cog.y + piece[p].box.y1;
  179.  
  180. wimpt_noerr(wimp_force_redraw(&r));
  181. }
  182.  
  183.