home *** CD-ROM | disk | FTP | other *** search
/ ISV Strong Games / ISV_STRONG_GAMES.iso / desktop / polysaw / !PolySaw / source / c / dragging next >
Text File  |  1990-07-30  |  12KB  |  551 lines
  1. /* 
  2. herein are functions called in response to a left button drag
  3. or right click in window "board", in mode Play.
  4. */
  5.  
  6. #include "wimp.h"
  7. #include "wimpt.h"
  8. #include "win.h"
  9. #include "event.h"
  10. #include "werr.h"
  11. #include "bbc.h" 
  12. #include "coords.h" 
  13.  
  14. #include <stdlib.h>
  15.  
  16. #include "Polysaw.h"
  17.  
  18. /* data structures for dragging */
  19. static  DragState        drag;
  20. static  Polymo           dragged;
  21.  
  22.  
  23. /************************ FUNCTIONS ************************/
  24.  
  25.  
  26. static  void    flip_piece(void);
  27. static  void    set_drag_state(coords_pointstr w, coords_pointstr m);
  28. static  void    start_drag(void);
  29. static  void    start_move_drag(void);
  30. static  void    start_spin_drag(void);
  31. static  void    update_move_drag(void);
  32. static  void    update_spin_drag(void);
  33. static  void    put_down_after_move(int wrk_x, int wrk_y);
  34. static  void    put_down_after_spin(coords_pointstr mse);
  35. static  void    eor_draw_moving_piece(int x, int y);
  36. static  void    eor_draw_spinning_piece(coords_pointstr);
  37.  
  38. static  void    put_down_poly(void);
  39. static  BOOL    room_for_dragged(void);
  40. static  void    find_spin_angle(int *sin, int *cos, coords_pointstr origin,                                    coords_pointstr from, coords_pointstr to);
  41.  
  42.  
  43. /*_____________________________________________________________*/
  44.  
  45.  
  46.  
  47.  
  48.  
  49.  
  50.  
  51.  
  52.  
  53.  
  54. void deal_with_play_but(coords_pointstr wrk, coords_pointstr mse,                                           wimp_bbits mse_b, wimp_box box)
  55. {
  56. wimp_dragstr    dragstr;          
  57.  
  58. if (mse_b & wimp_BRIGHT)  
  59.    {
  60.    if (which_piece(wrk) < MAX_PIECES)
  61.      {
  62.      drag.piece = which_piece(wrk);
  63.      dragged = piece[which_piece(wrk)];                        
  64.      flip_piece();
  65.      }
  66.    }
  67.  
  68. if (mse_b & wimp_BDRAGLEFT)
  69.    {
  70.    set_drag_state(wrk, mse);
  71.  
  72.    dragstr.window = board_wh;
  73.    dragstr.type = 7;
  74.    dragstr.parent = box;
  75.    wimpt_noerr(wimp_drag_box(&dragstr));
  76.    start_drag();
  77.  
  78.    }
  79. }
  80.  
  81.  
  82. void flip_piece(void)
  83. {
  84. int i;
  85.  
  86. for (i=0; i<dragged.nofunits; i++) 
  87.   {
  88.   dragged.units[i].x = -dragged.units[i].x;
  89.   }
  90. dragged.rotflipstate = 9 - dragged.rotflipstate;
  91.  
  92. put_down_poly();
  93. }
  94.  
  95.  
  96.  
  97.  
  98. void set_drag_state(coords_pointstr w, coords_pointstr m)
  99. {
  100. int p, i;
  101. coords_pointstr pt;
  102.  
  103. drag.start = m;
  104. drag.old = m;
  105.  
  106. for (p=0; p < nofpieces; p++)
  107.   {
  108.   pt.x = w.x - piece[p].cog.x;
  109.   pt.y = w.y - piece[p].cog.y;
  110.   /* pt is offset to centre of piece, as all piece info is rel. cog */
  111.   if ( coords_withinbox(&pt, &piece[p].box) )   
  112.      {
  113.      for (i=0; i < piece[p].nofunits; i++)
  114.         {
  115.         if ( abs(pt.x - piece[p].units[i].x) <= HS   &&   
  116.              abs(pt.y - piece[p].units[i].y) <= HS )   
  117.              {
  118.              drag.piece = p;
  119.              dragged = piece[p];
  120.              if (  (pt.x)*(pt.x) + (pt.y)*(pt.y) < piece[p].movespin_rad  )
  121.                  drag.kind = 1; 
  122.              else
  123.                  drag.kind = -1;
  124.              return;
  125.              }
  126.         }
  127.      }
  128.   }
  129. drag.kind = 0;
  130. drag.piece = MAX_PIECES+1;
  131. return;
  132. }
  133.  
  134.  
  135. void start_drag(void)
  136. {
  137. event_setmask((wimp_emask)0);
  138. if (drag.kind ==  1) start_move_drag(); 
  139. if (drag.kind == -1) start_spin_drag();
  140. }
  141.  
  142.  
  143.  
  144. void start_move_drag(void)
  145. {
  146. wimp_redrawstr r;
  147. int more;
  148.  
  149. r.w = board_wh;
  150. r.box = board_windefn->ex;
  151. wimpt_noerr(wimp_update_wind(&r, &more));
  152.  
  153. while (more)
  154.   {
  155.   eor_draw_moving_piece(drag.old.x, drag.old.y);
  156.   wimpt_noerr(wimp_get_rectangle(&r, &more));
  157.   } 
  158. } 
  159.  
  160.  
  161.  
  162. void start_spin_drag(void)
  163. {
  164. wimp_redrawstr r;
  165. int more;
  166. int i;
  167.  
  168. /* fill in outline defns in drag.lines[]. */
  169.  
  170. for (i=0; i < piece[drag.piece].nofunits; i++)
  171.   {
  172.   drag.lines[4*i+0].x0 = piece[drag.piece].units[i].x + HS;
  173.   drag.lines[4*i+0].y0 = piece[drag.piece].units[i].y + HS;
  174.   drag.lines[4*i+0].x1 = piece[drag.piece].units[i].x + HS;
  175.   drag.lines[4*i+0].y1 = piece[drag.piece].units[i].y - HS;
  176.  
  177.   drag.lines[4*i+1].x0 = piece[drag.piece].units[i].x + HS;
  178.   drag.lines[4*i+1].y0 = piece[drag.piece].units[i].y - HS;
  179.   drag.lines[4*i+1].x1 = piece[drag.piece].units[i].x - HS;
  180.   drag.lines[4*i+1].y1 = piece[drag.piece].units[i].y - HS;
  181.  
  182.   drag.lines[4*i+2].x0 = piece[drag.piece].units[i].x - HS;
  183.   drag.lines[4*i+2].y0 = piece[drag.piece].units[i].y - HS;
  184.   drag.lines[4*i+2].x1 = piece[drag.piece].units[i].x - HS;
  185.   drag.lines[4*i+2].y1 = piece[drag.piece].units[i].y + HS;
  186.  
  187.   drag.lines[4*i+3].x0 = piece[drag.piece].units[i].x - HS;
  188.   drag.lines[4*i+3].y0 = piece[drag.piece].units[i].y + HS;
  189.   drag.lines[4*i+3].x1 = piece[drag.piece].units[i].x + HS;
  190.   drag.lines[4*i+3].y1 = piece[drag.piece].units[i].y + HS;
  191.   }
  192.  
  193.  
  194. r.w = board_wh;
  195. r.box.x0 = piece[drag.piece].cog.x + 3*piece[drag.piece].box.x0/2;
  196. r.box.y0 = piece[drag.piece].cog.y + 3*piece[drag.piece].box.y0/2;
  197. r.box.x1 = piece[drag.piece].cog.x + 3*piece[drag.piece].box.x1/2;
  198. r.box.y1 = piece[drag.piece].cog.y + 3*piece[drag.piece].box.y1/2;
  199.  
  200. wimpt_noerr(wimp_update_wind(&r, &more));
  201.  
  202. while (more)
  203.   {
  204.   eor_draw_spinning_piece(drag.start);
  205.   wimpt_noerr(wimp_get_rectangle(&r, &more));
  206.   } 
  207. }
  208.  
  209.  
  210. void update_drag(void)
  211. {
  212. if (drag.kind ==  1) update_move_drag();  
  213. if (drag.kind == -1) update_spin_drag();  
  214. }
  215.  
  216.  
  217.  
  218.  
  219. void  update_move_drag(void)
  220. {
  221. wimp_mousestr  m;
  222. wimp_redrawstr r;
  223. int more;
  224. int wrk_x, wrk_y;
  225.  
  226. wimpt_noerr(wimp_get_point_info(&m));
  227.  
  228. r.w = board_wh;
  229. r.box = board_windefn->ex;
  230.  
  231. if (m.bbits) 
  232.   {
  233.   drag.new.x = m.x;
  234.   drag.new.y = m.y;
  235.   
  236.   wimpt_noerr(wimp_update_wind(&r, &more));
  237.   while (more)
  238.     {
  239.     eor_draw_moving_piece(drag.old.x, drag.old.y);
  240.     eor_draw_moving_piece(drag.new.x, drag.new.y);
  241.  
  242.     wimpt_noerr(wimp_get_rectangle(&r, &more));
  243.     }
  244.   drag.old = drag.new;
  245.   }
  246. else
  247.   {        
  248.   wimpt_noerr(wimp_update_wind(&r, &more));
  249.  
  250.   while (more)
  251.     {
  252.     eor_draw_moving_piece(drag.old.x, drag.old.y);           
  253.     wimpt_noerr(wimp_get_rectangle(&r, &more));
  254.     }
  255.  
  256.   wrk_x = coords_x_toworkarea(drag.old.x, (coords_cvtstr *)&r.box);
  257.   wrk_y = coords_y_toworkarea(drag.old.y, (coords_cvtstr *)&r.box);
  258.  
  259.   put_down_after_move(wrk_x, wrk_y);
  260.   }
  261. }
  262.  
  263.  
  264.  
  265. void update_spin_drag(void)
  266. {
  267. wimp_mousestr  m;
  268. wimp_redrawstr r;
  269. int more;
  270. int wrk_x, wrk_y;
  271.  
  272. wimpt_noerr(wimp_get_point_info(&m));
  273.  
  274. r.w = board_wh;
  275. r.box.x0 = piece[drag.piece].cog.x + 3*piece[drag.piece].box.x0/2;
  276. r.box.y0 = piece[drag.piece].cog.y + 3*piece[drag.piece].box.y0/2;
  277. r.box.x1 = piece[drag.piece].cog.x + 3*piece[drag.piece].box.x1/2;
  278. r.box.y1 = piece[drag.piece].cog.y + 3*piece[drag.piece].box.y1/2;
  279.  
  280. if (m.bbits) 
  281.   {
  282.   drag.new.x = m.x;
  283.   drag.new.y = m.y;
  284.   
  285.   wimpt_noerr(wimp_update_wind(&r, &more));
  286.   while (more)
  287.     {
  288.     eor_draw_spinning_piece(drag.old);
  289.     eor_draw_spinning_piece(drag.new);
  290.  
  291.     wimpt_noerr(wimp_get_rectangle(&r, &more));
  292.     }
  293.   drag.old.x = drag.new.x;
  294.   drag.old.y = drag.new.y;
  295.   }
  296. else
  297.   {    
  298.   wimpt_noerr(wimp_update_wind(&r, &more));
  299.  
  300.   while (more)
  301.     {
  302.     eor_draw_spinning_piece(drag.old);           
  303.     wimpt_noerr(wimp_get_rectangle(&r, &more));
  304.     }
  305.  
  306.   wrk_x = coords_x_toworkarea(drag.old.x, (coords_cvtstr *)&r.box);
  307.   wrk_y = coords_y_toworkarea(drag.old.y, (coords_cvtstr *)&r.box);
  308.  
  309.   put_down_after_spin(drag.old);
  310.   }
  311. }
  312.  
  313.  
  314.  
  315.  
  316.  
  317.  
  318. void eor_draw_moving_piece(int x, int y)
  319. {
  320. int i;
  321.  
  322. wimpt_noerr(wimp_setcolour( (0<<7) | (3<<4) | 2));
  323.  
  324. for (i=0; i < piece[drag.piece].nofunits; i++)
  325.       {
  326.         wimpt_noerr(bbc_rectangle(x + piece[drag.piece].units[i].x - HS,  y + piece[drag.piece].units[i].y - HS,  2*HS-1,  2*HS-1));
  327.       }
  328.  
  329. }
  330.  
  331.  
  332. void eor_draw_spinning_piece(coords_pointstr mse)
  333. {
  334. int             sin, cos;       /* use binary point at bit 12 */
  335. int             a, b, x0, y0, x1, y1, i;
  336. coords_pointstr cog;
  337. wimp_wstate     winstate;
  338.  
  339. wimpt_noerr(wimp_get_wind_state(board_wh, &winstate));
  340.  
  341. cog = piece[drag.piece].cog;
  342. coords_point_toscreen(&cog, (coords_cvtstr *)&winstate.o.box);
  343.  
  344. /* now  cog, drag.start, mse are in screen coords */
  345.  
  346. find_spin_angle(&sin, &cos, cog, drag.start, mse); 
  347.  
  348. /* draw rotated lines */
  349. for (i = 0; i < 4*(piece[drag.piece].nofunits); i++)
  350.   {
  351.   a = drag.lines[i].x0;
  352.   b = drag.lines[i].y0;
  353.   x0 = (int) ( ((a*cos)>>12) - ((b*sin)>>12) ) + cog.x;
  354.   y0 = (int) ( ((a*sin)>>12) + ((b*cos)>>12) ) + cog.y;
  355.   a = drag.lines[i].x1;
  356.   b = drag.lines[i].y1;
  357.   x1 = (int) ( ((a*cos)>>12) - ((b*sin)>>12) ) + cog.x;
  358.   y1 = (int) ( ((a*sin)>>12) + ((b*cos)>>12) ) + cog.y;
  359.  
  360.   wimpt_noerr(wimp_setcolour( (0<<7) | (3<<4) | 2));
  361.   wimpt_noerr(bbc_move(x0, y0));
  362.   wimpt_noerr(bbc_draw(x1, y1));
  363.   }
  364.  
  365. }
  366.  
  367.  
  368.  
  369.  
  370.  
  371. void put_down_after_move(int wrk_x, int wrk_y)
  372. {
  373. int cogmodgrid;
  374.  
  375. cogmodgrid = dragged.cog.x % (2*HS);
  376.   dragged.cog.x  =  roundtonearest(wrk_x - cogmodgrid, 2*HS) +                                                               cogmodgrid;
  377. cogmodgrid = dragged.cog.y % (2*HS);
  378.   dragged.cog.y  =  roundtonearest(wrk_y - cogmodgrid, 2*HS) +                                                               cogmodgrid;
  379. put_down_poly();
  380. }
  381.  
  382.  
  383. void put_down_after_spin(coords_pointstr mse)
  384. {
  385. int             sin, cos;
  386. int               i, ang, qtsin, qtcos;
  387. coords_pointstr   cog;
  388. wimp_wstate       winstate;
  389.  
  390. wimpt_noerr(wimp_get_wind_state(board_wh, &winstate));
  391.  
  392. cog = dragged.cog;
  393. coords_point_toscreen(&cog, (coords_cvtstr *)&winstate.o.box);
  394.  
  395. find_spin_angle(&sin, &cos, cog, drag.start, mse); 
  396.  
  397. if (   abs(sin) < (int) (0.7*4096)   ) 
  398.   {
  399.   qtsin = 0;
  400.   if (cos < 0)
  401.      { 
  402.      qtcos = -1;
  403.      ang=4;
  404.      }
  405.   else
  406.      {
  407.      qtcos = 1;
  408.      ang=0;
  409.      }
  410.   }
  411. else
  412.   {
  413.   qtcos = 0;
  414.   if (sin < 0)
  415.      {
  416.      qtsin = -1;
  417.      ang=6;
  418.      }
  419.   else
  420.      {
  421.      qtsin = 1;
  422.      ang=2;
  423.      }
  424.   }
  425.  
  426. if (ang==2 || ang==6)
  427.   {
  428.   int xfidget, yfidget;
  429.   xfidget = dragged.cog.x % (2*HS);
  430.   yfidget = dragged.cog.y % (2*HS);
  431.   dragged.cog.x = roundtonearest(dragged.cog.x, 2*HS) + yfidget;
  432.   dragged.cog.y = roundtonearest(dragged.cog.y, 2*HS) + xfidget;
  433.   }
  434.  
  435.  
  436. dragged.rotflipstate += ang;
  437. dragged.rotflipstate &= 7;
  438. for (i=0; i < dragged.nofunits; i++)
  439.   {
  440.   int x, y;
  441.  
  442.   x = dragged.units[i].x;
  443.   y = dragged.units[i].y;
  444.   dragged.units[i].x = x*qtcos - y*qtsin;
  445.   dragged.units[i].y = x*qtsin + y*qtcos;
  446.  
  447.   }
  448.  
  449. put_down_poly();
  450. }
  451.  
  452.  
  453.  
  454. void put_down_poly(void)
  455. {
  456. int i, p, x, y;
  457.  
  458. p= drag.piece;      
  459.  
  460. event_setmask((wimp_emask)1);
  461.  
  462. /* delete poly from grid[][] */ 
  463. for (i=0; i<piece[p].nofunits; i++)
  464.   {
  465.     x = piece[p].cog.x + piece[p].units[i].x;
  466.     y = piece[p].cog.y + piece[p].units[i].y;
  467.     grid[(-y-HS)/(2*HS)][(x-HS)/(2*HS)] &= ~PIECE_BIT;
  468.   }
  469.  
  470. if (room_for_dragged())
  471.   {
  472.   force_piece_redraw(drag.piece);   /* clear old position */
  473.   piece[drag.piece] = dragged;
  474.   force_piece_redraw(drag.piece);   /* draw new posn */
  475.   }
  476. else
  477.   bbc_vdu(7);
  478.  
  479. /* put poly back in grid, in new or old posn */
  480.  
  481. for (i=0; i<piece[p].nofunits; i++)
  482.   {
  483.     x = piece[p].cog.x + piece[p].units[i].x;
  484.     y = piece[p].cog.y + piece[p].units[i].y;
  485.     grid[(-y-HS)/(2*HS)][(x-HS)/(2*HS)] |= PIECE_BIT;
  486.   }
  487. drag.kind = 0;
  488. }
  489.  
  490.  
  491. BOOL    room_for_dragged(void)
  492. {
  493. int x,y,g,i, row, col;
  494. for (i=0; i<dragged.nofunits; i++)
  495.   {
  496.     x = dragged.cog.x + dragged.units[i].x;
  497.     y = dragged.cog.y + dragged.units[i].y;
  498.     col = (x-HS)/(2*HS);
  499.     row = (-y-HS)/(2*HS);
  500.     if (col<0 || row<0 || col>=MAX_BOARD || row>=MAX_BOARD)
  501.            return FALSE;
  502.     g = grid[row][col];
  503.     if ( g & (PIECE_BIT | SQUARE_BIT) )
  504.            return FALSE;
  505.   }
  506. return TRUE;
  507. }
  508.  
  509.  
  510.  
  511. void  find_spin_angle(int *sin, int *cos, coords_pointstr origin,                                    coords_pointstr from, coords_pointstr to)
  512. {
  513. int c, d;
  514. int fx, fy, tx, ty;
  515.  
  516. /*  a bit of trig.
  517. *
  518. *        origin
  519. *           *---------------to
  520. *            \ angle
  521. *             \
  522. *              \
  523. *               \
  524. *                \
  525. *                 \from
  526. */ 
  527.  
  528. fx = from.x - origin.x;
  529. fy = from.y - origin.y;
  530. tx = to.x - origin.x;
  531. ty = to.y - origin.y;
  532.  
  533. c = integer_sqrt(tx*tx + ty*ty);
  534. d = integer_sqrt(fx*fx + fy*fy);
  535.  
  536. d = c*d;
  537. if (c <= 8)
  538.   {
  539.   *sin = 4096;
  540.   *cos = 0;
  541.   }
  542. else
  543.   { 
  544.   *sin = ((fx*ty - fy*tx)<<12)/d;
  545.   *cos = ((fx*tx + fy*ty)<<12)/d;
  546.   }
  547. } 
  548.  
  549.  
  550.  
  551.