Add claw svg to make-install
[xboard.git] / board.c
1 /*
2  * board.c -- platform-independent drawing code for XBoard
3  *
4  * Copyright 1991 by Digital Equipment Corporation, Maynard,
5  * Massachusetts.
6  *
7  * Enhancements Copyright 1992-2001, 2002, 2003, 2004, 2005, 2006,
8  * 2007, 2008, 2009, 2010, 2011, 2012, 2013 Free Software Foundation, Inc.
9  *
10  * The following terms apply to Digital Equipment Corporation's copyright
11  * interest in XBoard:
12  * ------------------------------------------------------------------------
13  * All Rights Reserved
14  *
15  * Permission to use, copy, modify, and distribute this software and its
16  * documentation for any purpose and without fee is hereby granted,
17  * provided that the above copyright notice appear in all copies and that
18  * both that copyright notice and this permission notice appear in
19  * supporting documentation, and that the name of Digital not be
20  * used in advertising or publicity pertaining to distribution of the
21  * software without specific, written prior permission.
22  *
23  * DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
24  * ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
25  * DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
26  * ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
27  * WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
28  * ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
29  * SOFTWARE.
30  * ------------------------------------------------------------------------
31  *
32  * The following terms apply to the enhanced version of XBoard
33  * distributed by the Free Software Foundation:
34  * ------------------------------------------------------------------------
35  *
36  * GNU XBoard is free software: you can redistribute it and/or modify
37  * it under the terms of the GNU General Public License as published by
38  * the Free Software Foundation, either version 3 of the License, or (at
39  * your option) any later version.
40  *
41  * GNU XBoard is distributed in the hope that it will be useful, but
42  * WITHOUT ANY WARRANTY; without even the implied warranty of
43  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
44  * General Public License for more details.
45  *
46  * You should have received a copy of the GNU General Public License
47  * along with this program. If not, see http://www.gnu.org/licenses/.  *
48  *
49  *------------------------------------------------------------------------
50  ** See the file ChangeLog for a revision history.  */
51
52 #define HIGHDRAG 1
53
54 #include "config.h"
55
56 #include <stdio.h>
57 #include <ctype.h>
58 #include <signal.h>
59 #include <errno.h>
60 #include <sys/types.h>
61 #include <sys/stat.h>
62 #include <pwd.h>
63 #include <math.h>
64
65 #if STDC_HEADERS
66 # include <stdlib.h>
67 # include <string.h>
68 #else /* not STDC_HEADERS */
69 extern char *getenv();
70 # if HAVE_STRING_H
71 #  include <string.h>
72 # else /* not HAVE_STRING_H */
73 #  include <strings.h>
74 # endif /* not HAVE_STRING_H */
75 #endif /* not STDC_HEADERS */
76
77 #if TIME_WITH_SYS_TIME
78 # include <sys/time.h>
79 # include <time.h>
80 #else
81 # if HAVE_SYS_TIME_H
82 #  include <sys/time.h>
83 # else
84 #  include <time.h>
85 # endif
86 #endif
87
88 #if HAVE_UNISTD_H
89 # include <unistd.h>
90 #endif
91
92 #if HAVE_SYS_WAIT_H
93 # include <sys/wait.h>
94 #endif
95
96 #include "common.h"
97 #include "frontend.h"
98 #include "backend.h"
99 #include "xboard2.h"
100 #include "moves.h"
101 #include "board.h"
102 #include "draw.h"
103
104
105 #ifdef __EMX__
106 #ifndef HAVE_USLEEP
107 #define HAVE_USLEEP
108 #endif
109 #define usleep(t)   _sleep2(((t)+500)/1000)
110 #endif
111
112
113 int squareSize, lineGap;
114
115 int damage[2][BOARD_RANKS][BOARD_FILES];
116
117 /* There can be two pieces being animated at once: a player
118    can begin dragging a piece before the remote opponent has moved. */
119
120 AnimState anims[NrOfAnims];
121
122 static void DrawSquare P((int row, int column, ChessSquare piece, int do_flash));
123 static Boolean IsDrawArrowEnabled P((void));
124 static void DrawArrowHighlight P((int fromX, int fromY, int toX,int toY));
125 static void ArrowDamage P((int s_col, int s_row, int d_col, int d_row));
126
127 static void
128 drawHighlight (int file, int rank, int type)
129 {
130     int x, y;
131
132     if (lineGap == 0) return;
133
134     if (flipView) {
135         x = lineGap/2 + ((BOARD_WIDTH-1)-file) *
136           (squareSize + lineGap);
137         y = lineGap/2 + rank * (squareSize + lineGap);
138     } else {
139         x = lineGap/2 + file * (squareSize + lineGap);
140         y = lineGap/2 + ((BOARD_HEIGHT-1)-rank) *
141           (squareSize + lineGap);
142     }
143
144     DrawBorder(x,y, type, lineGap & 1); // pass whether lineGap is odd
145 }
146
147 int hi1X = -1, hi1Y = -1, hi2X = -1, hi2Y = -1;
148 int pm1X = -1, pm1Y = -1, pm2X = -1, pm2Y = -1;
149
150 void
151 SetHighlights (int fromX, int fromY, int toX, int toY)
152 {
153     int arrow = hi2X >= 0 && hi1Y >= 0 && IsDrawArrowEnabled();
154
155     if (hi1X != fromX || hi1Y != fromY) {
156         if (hi1X >= 0 && hi1Y >= 0) {
157             drawHighlight(hi1X, hi1Y, 0);
158         }
159     } // [HGM] first erase both, then draw new!
160
161     if (hi2X != toX || hi2Y != toY) {
162         if (hi2X >= 0 && hi2Y >= 0) {
163             drawHighlight(hi2X, hi2Y, 0);
164         }
165     }
166
167     if(arrow) // there currently is an arrow displayed
168         ArrowDamage(hi1X, hi1Y, hi2X, hi2Y); // mark which squares it damaged
169
170     if (hi1X != fromX || hi1Y != fromY) {
171         if (fromX >= 0 && fromY >= 0) {
172             drawHighlight(fromX, fromY, 1);
173         }
174     }
175     if (hi2X != toX || hi2Y != toY) {
176         if (toX >= 0 && toY >= 0) {
177             drawHighlight(toX, toY, 1);
178         }
179     }
180
181     hi1X = fromX;
182     hi1Y = fromY;
183     hi2X = toX;
184     hi2Y = toY;
185
186     if(arrow || toX >= 0 && fromY >= 0 && IsDrawArrowEnabled())
187         DrawPosition(FALSE, NULL); // repair any arrow damage, or draw a new one
188 }
189
190 void
191 ClearHighlights ()
192 {
193     SetHighlights(-1, -1, -1, -1);
194 }
195
196
197 void
198 SetPremoveHighlights (int fromX, int fromY, int toX, int toY)
199 {
200     if (pm1X != fromX || pm1Y != fromY) {
201         if (pm1X >= 0 && pm1Y >= 0) {
202             drawHighlight(pm1X, pm1Y, 0);
203         }
204         if (fromX >= 0 && fromY >= 0) {
205             drawHighlight(fromX, fromY, 2);
206         }
207     }
208     if (pm2X != toX || pm2Y != toY) {
209         if (pm2X >= 0 && pm2Y >= 0) {
210             drawHighlight(pm2X, pm2Y, 0);
211         }
212         if (toX >= 0 && toY >= 0) {
213             drawHighlight(toX, toY, 2);
214         }
215     }
216     pm1X = fromX;
217     pm1Y = fromY;
218     pm2X = toX;
219     pm2Y = toY;
220 }
221
222 void
223 ClearPremoveHighlights ()
224 {
225   SetPremoveHighlights(-1, -1, -1, -1);
226 }
227
228 /*
229  * If the user selects on a border boundary, return -1; if off the board,
230  *   return -2.  Otherwise map the event coordinate to the square.
231  */
232 int
233 EventToSquare (int x, int limit)
234 {
235     if (x <= 0)
236       return -2;
237     if (x < lineGap)
238       return -1;
239     x -= lineGap;
240     if ((x % (squareSize + lineGap)) >= squareSize)
241       return -1;
242     x /= (squareSize + lineGap);
243     if (x >= limit)
244       return -2;
245     return x;
246 }
247
248 /* [HR] determine square color depending on chess variant. */
249 int
250 SquareColor (int row, int column)
251 {
252     int square_color;
253
254     if (gameInfo.variant == VariantXiangqi) {
255         if (column >= 3 && column <= 5 && row >= 0 && row <= 2) {
256             square_color = 1;
257         } else if (column >= 3 && column <= 5 && row >= 7 && row <= 9) {
258             square_color = 0;
259         } else if (row <= 4) {
260             square_color = 0;
261         } else {
262             square_color = 1;
263         }
264     } else {
265         square_color = ((column + row) % 2) == 1;
266     }
267
268     /* [hgm] holdings: next line makes all holdings squares light */
269     if(column < BOARD_LEFT || column >= BOARD_RGHT) square_color = 1;
270
271     if ( // [HGM] holdings: blank out area between board and holdings
272                  column == BOARD_LEFT-1
273              ||  column == BOARD_RGHT
274              || (column == BOARD_LEFT-2 && row < BOARD_HEIGHT-gameInfo.holdingsSize)
275              || (column == BOARD_RGHT+1 && row >= gameInfo.holdingsSize) )
276         square_color = 2; // black
277
278     return square_color;
279 }
280
281 /*      Convert board position to corner of screen rect and color       */
282
283 void
284 ScreenSquare (int column, int row, Pnt *pt, int *color)
285 {
286   if (flipView) {
287     pt->x = lineGap + ((BOARD_WIDTH-1)-column) * (squareSize + lineGap);
288     pt->y = lineGap + row * (squareSize + lineGap);
289   } else {
290     pt->x = lineGap + column * (squareSize + lineGap);
291     pt->y = lineGap + ((BOARD_HEIGHT-1)-row) * (squareSize + lineGap);
292   }
293   *color = SquareColor(row, column);
294 }
295
296 /*      Convert window coords to square                 */
297
298 void
299 BoardSquare (int x, int y, int *column, int *row)
300 {
301   *column = EventToSquare(x, BOARD_WIDTH);
302   if (flipView && *column >= 0)
303     *column = BOARD_WIDTH - 1 - *column;
304   *row = EventToSquare(y, BOARD_HEIGHT);
305   if (!flipView && *row >= 0)
306     *row = BOARD_HEIGHT - 1 - *row;
307 }
308
309 /*      Generate a series of frame coords from start->mid->finish.
310         The movement rate doubles until the half way point is
311         reached, then halves back down to the final destination,
312         which gives a nice slow in/out effect. The algorithmn
313         may seem to generate too many intermediates for short
314         moves, but remember that the purpose is to attract the
315         viewers attention to the piece about to be moved and
316         then to where it ends up. Too few frames would be less
317         noticeable.                                             */
318
319 static void
320 Tween (Pnt *start, Pnt *mid, Pnt *finish, int factor, Pnt frames[], int *nFrames)
321 {
322   int fraction, n, count;
323
324   count = 0;
325
326   /* Slow in, stepping 1/16th, then 1/8th, ... */
327   fraction = 1;
328   for (n = 0; n < factor; n++)
329     fraction *= 2;
330   for (n = 0; n < factor; n++) {
331     frames[count].x = start->x + (mid->x - start->x) / fraction;
332     frames[count].y = start->y + (mid->y - start->y) / fraction;
333     count ++;
334     fraction = fraction / 2;
335   }
336
337   /* Midpoint */
338   frames[count] = *mid;
339   count ++;
340
341   /* Slow out, stepping 1/2, then 1/4, ... */
342   fraction = 2;
343   for (n = 0; n < factor; n++) {
344     frames[count].x = finish->x - (finish->x - mid->x) / fraction;
345     frames[count].y = finish->y - (finish->y - mid->y) / fraction;
346     count ++;
347     fraction = fraction * 2;
348   }
349   *nFrames = count;
350 }
351
352 /****   Animation code by Hugh Fisher, DCS, ANU.
353
354         Known problem: if a window overlapping the board is
355         moved away while a piece is being animated underneath,
356         the newly exposed area won't be updated properly.
357         I can live with this.
358
359         Known problem: if you look carefully at the animation
360         of pieces in mono mode, they are being drawn as solid
361         shapes without interior detail while moving. Fixing
362         this would be a major complication for minimal return.
363 ****/
364
365 /*   Utilities  */
366
367 #undef Max  /* just in case */
368 #undef Min
369 #define Max(a, b) ((a) > (b) ? (a) : (b))
370 #define Min(a, b) ((a) < (b) ? (a) : (b))
371
372 typedef struct {
373   short int x, y, width, height;
374 } MyRectangle;
375
376 void
377 DoSleep (int n)
378 {
379     FrameDelay(n);
380 }
381
382 static void
383 SetRect (MyRectangle *rect, int x, int y, int width, int height)
384 {
385   rect->x = x;
386   rect->y = y;
387   rect->width  = width;
388   rect->height = height;
389 }
390
391 /*      Test if two frames overlap. If they do, return
392         intersection rect within old and location of
393         that rect within new. */
394
395 static Boolean
396 Intersect ( Pnt *old, Pnt *new, int size, MyRectangle *area, Pnt *pt)
397 {
398   if (old->x > new->x + size || new->x > old->x + size ||
399       old->y > new->y + size || new->y > old->y + size) {
400     return False;
401   } else {
402     SetRect(area, Max(new->x - old->x, 0), Max(new->y - old->y, 0),
403             size - abs(old->x - new->x), size - abs(old->y - new->y));
404     pt->x = Max(old->x - new->x, 0);
405     pt->y = Max(old->y - new->y, 0);
406     return True;
407   }
408 }
409
410 /*      For two overlapping frames, return the rect(s)
411         in the old that do not intersect with the new.   */
412
413 static void
414 CalcUpdateRects (Pnt *old, Pnt *new, int size, MyRectangle update[], int *nUpdates)
415 {
416   int        count;
417
418   /* If old = new (shouldn't happen) then nothing to draw */
419   if (old->x == new->x && old->y == new->y) {
420     *nUpdates = 0;
421     return;
422   }
423   /* Work out what bits overlap. Since we know the rects
424      are the same size we don't need a full intersect calc. */
425   count = 0;
426   /* Top or bottom edge? */
427   if (new->y > old->y) {
428     SetRect(&(update[count]), old->x, old->y, size, new->y - old->y);
429     count ++;
430   } else if (old->y > new->y) {
431     SetRect(&(update[count]), old->x, old->y + size - (old->y - new->y),
432                               size, old->y - new->y);
433     count ++;
434   }
435   /* Left or right edge - don't overlap any update calculated above. */
436   if (new->x > old->x) {
437     SetRect(&(update[count]), old->x, Max(new->y, old->y),
438                               new->x - old->x, size - abs(new->y - old->y));
439     count ++;
440   } else if (old->x > new->x) {
441     SetRect(&(update[count]), new->x + size, Max(new->y, old->y),
442                               old->x - new->x, size - abs(new->y - old->y));
443     count ++;
444   }
445   /* Done */
446   *nUpdates = count;
447 }
448
449 /* Animate the movement of a single piece */
450
451 static void
452 BeginAnimation (AnimNr anr, ChessSquare piece, ChessSquare bgPiece, int startColor, Pnt *start)
453 {
454   AnimState *anim = &anims[anr];
455
456   if(appData.upsideDown && flipView) piece += piece < BlackPawn ? BlackPawn : -BlackPawn;
457   /* The old buffer is initialised with the start square (empty) */
458   if(bgPiece == EmptySquare) {
459     DrawBlank(anr, start->x, start->y, startColor);
460   } else {
461        /* Kludge alert: When gating we want the introduced
462           piece to appear on the from square. To generate an
463           image of it, we draw it on the board, copy the image,
464           and draw the original piece again. */
465        if(piece != bgPiece) DrawSquare(anim->startBoardY, anim->startBoardX, bgPiece, 0);
466        CopyRectangle(anr, DISP, 2,
467                  start->x, start->y, squareSize, squareSize,
468                  0, 0); // [HGM] zh: unstack in stead of grab
469        if(piece != bgPiece) DrawSquare(anim->startBoardY, anim->startBoardX, piece, 0);
470   }
471   anim->prevFrame = *start;
472
473   SetDragPiece(anr, piece);
474 }
475
476 static void
477 AnimationFrame (AnimNr anr, Pnt *frame, ChessSquare piece)
478 {
479   MyRectangle updates[4];
480   MyRectangle overlap;
481   Pnt     pt;
482   AnimState *anim = &anims[anr];
483   int     count, i, x, y, w, h;
484
485   /* Save what we are about to draw into the new buffer */
486   CopyRectangle(anr, DISP, 0,
487             x = frame->x, y = frame->y, w = squareSize, h = squareSize,
488             0, 0);
489
490   /* Erase bits of the previous frame */
491   if (Intersect(&anim->prevFrame, frame, squareSize, &overlap, &pt)) {
492     /* Where the new frame overlapped the previous,
493        the contents in newBuf are wrong. */
494     CopyRectangle(anr, 2, 0,
495               overlap.x, overlap.y,
496               overlap.width, overlap.height,
497               pt.x, pt.y);
498     /* Repaint the areas in the old that don't overlap new */
499     CalcUpdateRects(&anim->prevFrame, frame, squareSize, updates, &count);
500     for (i = 0; i < count; i++)
501       CopyRectangle(anr, 2, DISP,
502                 updates[i].x - anim->prevFrame.x,
503                 updates[i].y - anim->prevFrame.y,
504                 updates[i].width, updates[i].height,
505                 updates[i].x, updates[i].y);
506     /* [HGM] correct expose rectangle to encompass both overlapping squares */
507     if(x > anim->prevFrame.x) w += x - anim->prevFrame.x, x = anim->prevFrame.x;
508     else  w += anim->prevFrame.x - x;
509     if(y > anim->prevFrame.y) h += y - anim->prevFrame.y, y = anim->prevFrame.y;
510     else  h += anim->prevFrame.y - y;
511   } else {
512     /* Easy when no overlap */
513     CopyRectangle(anr, 2, DISP,
514                   0, 0, squareSize, squareSize,
515                   anim->prevFrame.x, anim->prevFrame.y);
516     GraphExpose(currBoard, anim->prevFrame.x, anim->prevFrame.y, squareSize, squareSize);
517   }
518
519   /* Save this frame for next time round */
520   CopyRectangle(anr, 0, 2,
521                 0, 0, squareSize, squareSize,
522                 0, 0);
523   anim->prevFrame = *frame;
524
525   /* Draw piece over original screen contents, not current,
526      and copy entire rect. Wipes out overlapping piece images. */
527   InsertPiece(anr, piece);
528   CopyRectangle(anr, 0, DISP,
529                 0, 0, squareSize, squareSize,
530                 frame->x, frame->y);
531   GraphExpose(currBoard, x, y, w, h);
532 }
533
534 static void
535 EndAnimation (AnimNr anr, Pnt *finish)
536 {
537   MyRectangle updates[4];
538   MyRectangle overlap;
539   Pnt     pt;
540   int        count, i;
541   AnimState *anim = &anims[anr];
542
543   /* The main code will redraw the final square, so we
544      only need to erase the bits that don't overlap.    */
545   if (Intersect(&anim->prevFrame, finish, squareSize, &overlap, &pt)) {
546     CalcUpdateRects(&anim->prevFrame, finish, squareSize, updates, &count);
547     for (i = 0; i < count; i++)
548       CopyRectangle(anr, 2, DISP,
549                 updates[i].x - anim->prevFrame.x,
550                 updates[i].y - anim->prevFrame.y,
551                 updates[i].width, updates[i].height,
552                 updates[i].x, updates[i].y);
553   } else {
554     CopyRectangle(anr, 2, DISP,
555                 0, 0, squareSize, squareSize,
556                 anim->prevFrame.x, anim->prevFrame.y);
557   }
558 }
559
560 static void
561 FrameSequence (AnimNr anr, ChessSquare piece, int startColor, Pnt *start, Pnt *finish, Pnt frames[], int nFrames)
562 {
563   int n;
564
565   BeginAnimation(anr, piece, EmptySquare, startColor, start);
566   for (n = 0; n < nFrames; n++) {
567     AnimationFrame(anr, &(frames[n]), piece);
568     FrameDelay(appData.animSpeed);
569   }
570   EndAnimation(anr, finish);
571 }
572
573 void
574 AnimateAtomicCapture (Board board, int fromX, int fromY, int toX, int toY)
575 {
576     int i, x, y;
577     ChessSquare piece = board[fromY][toY];
578     board[fromY][toY] = EmptySquare;
579     DrawPosition(FALSE, board);
580     if (flipView) {
581         x = lineGap + ((BOARD_WIDTH-1)-toX) * (squareSize + lineGap);
582         y = lineGap + toY * (squareSize + lineGap);
583     } else {
584         x = lineGap + toX * (squareSize + lineGap);
585         y = lineGap + ((BOARD_HEIGHT-1)-toY) * (squareSize + lineGap);
586     }
587     for(i=1; i<4*kFactor; i++) {
588         int r = squareSize * 9 * i/(20*kFactor - 5);
589         DrawDot(1, x + squareSize/2 - r, y+squareSize/2 - r, 2*r);
590         FrameDelay(appData.animSpeed);
591     }
592     board[fromY][toY] = piece;
593     DrawGrid();
594 }
595
596 /* Main control logic for deciding what to animate and how */
597
598 void
599 AnimateMove (Board board, int fromX, int fromY, int toX, int toY)
600 {
601   ChessSquare piece;
602   int hop;
603   Pnt      start, finish, mid;
604   Pnt      frames[kFactor * 2 + 1];
605   int         nFrames, startColor, endColor;
606
607   /* Are we animating? */
608   if (!appData.animate || appData.blindfold)
609     return;
610
611   if(board[toY][toX] == WhiteRook && board[fromY][fromX] == WhiteKing ||
612      board[toY][toX] == BlackRook && board[fromY][fromX] == BlackKing)
613         return; // [HGM] FRC: no animtion of FRC castlings, as to-square is not true to-square
614
615   if (fromY < 0 || fromX < 0 || toX < 0 || toY < 0) return;
616   piece = board[fromY][fromX];
617   if (piece >= EmptySquare) return;
618
619 #if DONT_HOP
620   hop = FALSE;
621 #else
622   hop = abs(fromX-toX) == 1 && abs(fromY-toY) == 2 || abs(fromX-toX) == 2 && abs(fromY-toY) == 1;
623 #endif
624
625   ScreenSquare(fromX, fromY, &start, &startColor);
626   ScreenSquare(toX, toY, &finish, &endColor);
627
628   if (hop) {
629     /* Knight: make straight movement then diagonal */
630     if (abs(toY - fromY) < abs(toX - fromX)) {
631        mid.x = start.x + (finish.x - start.x) / 2;
632        mid.y = start.y;
633      } else {
634        mid.x = start.x;
635        mid.y = start.y + (finish.y - start.y) / 2;
636      }
637   } else {
638     mid.x = start.x + (finish.x - start.x) / 2;
639     mid.y = start.y + (finish.y - start.y) / 2;
640   }
641
642   /* Don't use as many frames for very short moves */
643   if (abs(toY - fromY) + abs(toX - fromX) <= 2)
644     Tween(&start, &mid, &finish, kFactor - 1, frames, &nFrames);
645   else
646     Tween(&start, &mid, &finish, kFactor, frames, &nFrames);
647   FrameSequence(Game, piece, startColor, &start, &finish, frames, nFrames);
648   if(Explode(board, fromX, fromY, toX, toY)) { // mark as damaged
649     int i,j;
650     for(i=0; i<BOARD_WIDTH; i++) for(j=0; j<BOARD_HEIGHT; j++)
651       if((i-toX)*(i-toX) + (j-toY)*(j-toY) < 6) damage[0][j][i] |=  1 + ((i-toX ^ j-toY) & 1);
652   }
653
654   /* Be sure end square is redrawn */
655   damage[0][toY][toX] |= True;
656 }
657
658 void
659 ChangeDragPiece (ChessSquare piece)
660 {
661   anims[Player].dragPiece = piece;
662   SetDragPiece(Player, piece);
663 }
664
665 void
666 DragPieceMove (int x, int y)
667 {
668     Pnt corner;
669
670     /* Are we animating? */
671     if (!appData.animateDragging || appData.blindfold)
672       return;
673
674     /* Sanity check */
675     if (! anims[Player].dragActive)
676       return;
677     /* Move piece, maintaining same relative position
678        of mouse within square    */
679     corner.x = x - anims[Player].mouseDelta.x;
680     corner.y = y - anims[Player].mouseDelta.y;
681     AnimationFrame(Player, &corner, anims[Player].dragPiece);
682 #if HIGHDRAG*0
683     if (appData.highlightDragging) {
684         int boardX, boardY;
685         BoardSquare(x, y, &boardX, &boardY);
686         SetHighlights(fromX, fromY, boardX, boardY);
687     }
688 #endif
689 }
690
691 void
692 DragPieceEnd (int x, int y)
693 {
694     int boardX, boardY, color;
695     Pnt corner;
696
697     /* Are we animating? */
698     if (!appData.animateDragging || appData.blindfold)
699       return;
700
701     /* Sanity check */
702     if (! anims[Player].dragActive)
703       return;
704     /* Last frame in sequence is square piece is
705        placed on, which may not match mouse exactly. */
706     BoardSquare(x, y, &boardX, &boardY);
707     ScreenSquare(boardX, boardY, &corner, &color);
708     EndAnimation(Player, &corner);
709
710     /* Be sure end square is redrawn */
711     damage[0][boardY][boardX] = True;
712
713     /* This prevents weird things happening with fast successive
714        clicks which on my Sun at least can cause motion events
715        without corresponding press/release. */
716     anims[Player].dragActive = False;
717 }
718
719 void
720 DragPieceBegin (int x, int y, Boolean instantly)
721 {
722     int  boardX, boardY, color;
723     Pnt corner;
724
725     /* Are we animating? */
726     if (!appData.animateDragging || appData.blindfold)
727       return;
728
729     /* Figure out which square we start in and the
730        mouse position relative to top left corner. */
731     BoardSquare(x, y, &boardX, &boardY);
732     anims[Player].startBoardX = boardX;
733     anims[Player].startBoardY = boardY;
734     ScreenSquare(boardX, boardY, &corner, &color);
735     anims[Player].startSquare  = corner;
736     anims[Player].startColor   = color;
737     /* As soon as we start dragging, the piece will jump slightly to
738        be centered over the mouse pointer. */
739     anims[Player].mouseDelta.x = squareSize/2;
740     anims[Player].mouseDelta.y = squareSize/2;
741     /* Initialise animation */
742     anims[Player].dragPiece = PieceForSquare(boardX, boardY);
743     /* Sanity check */
744     if (anims[Player].dragPiece >= 0 && anims[Player].dragPiece < EmptySquare) {
745         ChessSquare bgPiece = EmptySquare;
746         anims[Player].dragActive = True;
747         if(boardX == BOARD_RGHT+1 && PieceForSquare(boardX-1, boardY) > 1 ||
748            boardX == BOARD_LEFT-2 && PieceForSquare(boardX+1, boardY) > 1)
749             bgPiece = anims[Player].dragPiece;
750         if(gatingPiece != EmptySquare) bgPiece = gatingPiece;
751         BeginAnimation(Player, anims[Player].dragPiece, bgPiece, color, &corner);
752         /* Mark this square as needing to be redrawn. Note that
753            we don't remove the piece though, since logically (ie
754            as seen by opponent) the move hasn't been made yet. */
755         damage[0][boardY][boardX] = True;
756     } else {
757         anims[Player].dragActive = False;
758     }
759 }
760
761 /* Handle expose event while piece being dragged */
762
763 static void
764 DrawDragPiece ()
765 {
766   if (!anims[Player].dragActive || appData.blindfold)
767     return;
768
769   /* What we're doing: logically, the move hasn't been made yet,
770      so the piece is still in it's original square. But visually
771      it's being dragged around the board. So we erase the square
772      that the piece is on and draw it at the last known drag point. */
773   DrawOneSquare(anims[Player].startSquare.x, anims[Player].startSquare.y,
774                 EmptySquare, anims[Player].startColor, 0, NULL, NULL, 0);
775   AnimationFrame(Player, &anims[Player].prevFrame, anims[Player].dragPiece);
776   damage[0][anims[Player].startBoardY][anims[Player].startBoardX] = TRUE;
777 }
778
779 static void
780 DrawSquare (int row, int column, ChessSquare piece, int do_flash)
781 {
782     int square_color, x, y, align=0;
783     int i;
784     char tString[3], bString[2];
785     int flash_delay;
786
787     /* Calculate delay in milliseconds (2-delays per complete flash) */
788     flash_delay = 500 / appData.flashRate;
789
790     if (flipView) {
791         x = lineGap + ((BOARD_WIDTH-1)-column) *
792           (squareSize + lineGap);
793         y = lineGap + row * (squareSize + lineGap);
794     } else {
795         x = lineGap + column * (squareSize + lineGap);
796         y = lineGap + ((BOARD_HEIGHT-1)-row) *
797           (squareSize + lineGap);
798     }
799
800     square_color = SquareColor(row, column);
801
802     bString[1] = bString[0] = NULLCHAR;
803     if (appData.showCoords && row == (flipView ? BOARD_HEIGHT-1 : 0)
804                 && column >= BOARD_LEFT && column < BOARD_RGHT) {
805         bString[0] = 'a' + column - BOARD_LEFT;
806         align = 1; // coord in lower-right corner
807     }
808     if (appData.showCoords && column == (flipView ? BOARD_RGHT-1 : BOARD_LEFT)) {
809         snprintf(tString, 3, "%d", ONE - '0' + row);
810         align = 2; // coord in upper-left corner
811     }
812     if (column == (flipView ? BOARD_LEFT-1 : BOARD_RGHT) && piece > 1 ) {
813         snprintf(tString, 3, "%d", piece);
814         align = 3; // holdings count in upper-right corner
815     }
816     if (column == (flipView ? BOARD_RGHT : BOARD_LEFT-1) && piece > 1) {
817         snprintf(tString, 3, "%d", piece);
818         align = 4; // holdings count in upper-left corner
819     }
820     if(piece == DarkSquare) square_color = 2;
821     if(square_color == 2 || appData.blindfold) piece = EmptySquare;
822
823     if (do_flash && piece != EmptySquare && appData.flashCount > 0) {
824         for (i=0; i<appData.flashCount; ++i) {
825             DrawOneSquare(x, y, piece, square_color, 0, tString, bString, 0);
826             GraphExpose(currBoard, x, y, squareSize, squareSize);
827             FlashDelay(flash_delay);
828             DrawOneSquare(x, y, EmptySquare, square_color, 0, tString, bString, 0);
829             GraphExpose(currBoard, x, y, squareSize, squareSize);
830             FlashDelay(flash_delay);
831         }
832     }
833     DrawOneSquare(x, y, piece, square_color, partnerUp ? 0 : marker[row][column], tString, bString, align);
834 }
835
836 /* Returns 1 if there are "too many" differences between b1 and b2
837    (i.e. more than 1 move was made) */
838 static int
839 too_many_diffs (Board b1, Board b2)
840 {
841     int i, j;
842     int c = 0;
843
844     for (i=0; i<BOARD_HEIGHT; ++i) {
845         for (j=0; j<BOARD_WIDTH; ++j) {
846             if (b1[i][j] != b2[i][j]) {
847                 if (++c > 4)    /* Castling causes 4 diffs */
848                   return 1;
849             }
850         }
851     }
852     return 0;
853 }
854
855 /* Matrix describing castling maneuvers */
856 /* Row, ColRookFrom, ColKingFrom, ColRookTo, ColKingTo */
857 static int castling_matrix[4][5] = {
858     { 0, 0, 4, 3, 2 },          /* 0-0-0, white */
859     { 0, 7, 4, 5, 6 },          /* 0-0,   white */
860     { 7, 0, 4, 3, 2 },          /* 0-0-0, black */
861     { 7, 7, 4, 5, 6 }           /* 0-0,   black */
862 };
863
864 /* Checks whether castling occurred. If it did, *rrow and *rcol
865    are set to the destination (row,col) of the rook that moved.
866
867    Returns 1 if castling occurred, 0 if not.
868
869    Note: Only handles a max of 1 castling move, so be sure
870    to call too_many_diffs() first.
871    */
872 static int
873 check_castle_draw (Board newb, Board oldb, int *rrow, int *rcol)
874 {
875     int i, *r, j;
876     int match;
877
878     /* For each type of castling... */
879     for (i=0; i<4; ++i) {
880         r = castling_matrix[i];
881
882         /* Check the 4 squares involved in the castling move */
883         match = 0;
884         for (j=1; j<=4; ++j) {
885             if (newb[r[0]][r[j]] == oldb[r[0]][r[j]]) {
886                 match = 1;
887                 break;
888             }
889         }
890
891         if (!match) {
892             /* All 4 changed, so it must be a castling move */
893             *rrow = r[0];
894             *rcol = r[3];
895             return 1;
896         }
897     }
898     return 0;
899 }
900
901 void
902 DrawPosition (int repaint, Board board)
903 {
904     int i, j, do_flash, exposeAll = False;
905     static int lastFlipView = 0;
906     static int lastBoardValid[2] = {0, 0};
907     static Board lastBoard[2];
908     static char lastMarker[BOARD_RANKS][BOARD_FILES];
909     int rrow, rcol;
910     int nr = twoBoards*partnerUp;
911
912     if(DrawSeekGraph()) return; // [HGM] seekgraph: suppress any drawing if seek graph up
913
914     if (board == NULL) {
915         if (!lastBoardValid[nr]) return;
916         board = lastBoard[nr];
917     }
918     if (!lastBoardValid[nr] || (nr == 0 && lastFlipView != flipView)) {
919         MarkMenuItem("View.Flip View", flipView);
920     }
921
922     if(nr) { SlavePopUp(); SwitchWindow(0); } // [HGM] popup board if not yet popped up, and switch drawing to it.
923
924     /*
925      * It would be simpler to clear the window with XClearWindow()
926      * but this causes a very distracting flicker.
927      */
928
929     if (!repaint && lastBoardValid[nr] && (nr == 1 || lastFlipView == flipView)) {
930
931 //      if ( lineGap && IsDrawArrowEnabled())
932 //          DrawGrid();
933
934         /* If too much changes (begin observing new game, etc.), don't
935            do flashing */
936         do_flash = too_many_diffs(board, lastBoard[nr]) ? 0 : 1;
937
938         /* Special check for castling so we don't flash both the king
939            and the rook (just flash the king). */
940         if (do_flash) {
941             if (check_castle_draw(board, lastBoard[nr], &rrow, &rcol)) {
942                 /* Mark rook for drawing with NO flashing. */
943                 damage[nr][rrow][rcol] |= 1;
944             }
945         }
946
947         /* First pass -- Draw (newly) empty squares and repair damage.
948            This prevents you from having a piece show up twice while it
949            is flashing on its new square */
950         for (i = 0; i < BOARD_HEIGHT; i++)
951           for (j = 0; j < BOARD_WIDTH; j++)
952             if (((board[i][j] != lastBoard[nr][i][j] || !nr && marker[i][j] != lastMarker[i][j]) && board[i][j] == EmptySquare)
953                 || damage[nr][i][j]) {
954                 DrawSquare(i, j, board[i][j], 0);
955                 if(damage[nr][i][j] & 2) {
956                     drawHighlight(j, i, 0);   // repair arrow damage
957                     if(lineGap) damage[nr][i][j] = False; // this flushed the square as well
958                 } else damage[nr][i][j] = 1;  // mark for expose
959             }
960
961         /* Second pass -- Draw piece(s) in new position and flash them */
962         for (i = 0; i < BOARD_HEIGHT; i++)
963           for (j = 0; j < BOARD_WIDTH; j++)
964             if (board[i][j] != lastBoard[nr][i][j] || !nr && marker[i][j] != lastMarker[i][j]) {
965                 DrawSquare(i, j, board[i][j], do_flash);
966                 damage[nr][i][j] = 1; // mark for expose
967             }
968     } else {
969         if (lineGap > 0)
970           DrawGrid();
971
972         for (i = 0; i < BOARD_HEIGHT; i++)
973           for (j = 0; j < BOARD_WIDTH; j++) {
974               DrawSquare(i, j, board[i][j], 0);
975               damage[nr][i][j] = False;
976           }
977
978         exposeAll = True;
979     }
980
981     CopyBoard(lastBoard[nr], board);
982     lastBoardValid[nr] = 1;
983   if(nr == 0) { // [HGM] dual: no highlights on second board yet
984     lastFlipView = flipView;
985     for (i = 0; i < BOARD_HEIGHT; i++)
986         for (j = 0; j < BOARD_WIDTH; j++)
987             lastMarker[i][j] = marker[i][j];
988
989     /* Draw highlights */
990     if (pm1X >= 0 && pm1Y >= 0) {
991       drawHighlight(pm1X, pm1Y, 2);
992       if(lineGap) damage[nr][pm1Y][pm1X] = False;
993     }
994     if (pm2X >= 0 && pm2Y >= 0) {
995       drawHighlight(pm2X, pm2Y, 2);
996       if(lineGap) damage[nr][pm2Y][pm2X] = False;
997     }
998     if (hi1X >= 0 && hi1Y >= 0) {
999       drawHighlight(hi1X, hi1Y, 1);
1000       if(lineGap) damage[nr][hi1Y][hi1X] = False;
1001     }
1002     if (hi2X >= 0 && hi2Y >= 0) {
1003       drawHighlight(hi2X, hi2Y, 1);
1004       if(lineGap) damage[nr][hi2Y][hi2X] = False;
1005     }
1006     DrawArrowHighlight(hi1X, hi1Y, hi2X, hi2Y);
1007   }
1008   else DrawArrowHighlight (board[EP_STATUS-3], board[EP_STATUS-4], board[EP_STATUS-1], board[EP_STATUS-2]);
1009
1010     /* If piece being dragged around board, must redraw that too */
1011     DrawDragPiece();
1012
1013     if(exposeAll)
1014         GraphExpose(currBoard, 0, 0, BOARD_WIDTH*(squareSize + lineGap) + lineGap, BOARD_HEIGHT*(squareSize + lineGap) + lineGap);
1015     else {
1016         for (i = 0; i < BOARD_HEIGHT; i++)
1017             for (j = 0; j < BOARD_WIDTH; j++)
1018                 if(damage[nr][i][j]) {
1019                     int x, y;
1020                     if (flipView) {
1021                         x = lineGap + ((BOARD_WIDTH-1)-j) *
1022                           (squareSize + lineGap);
1023                         y = lineGap + i * (squareSize + lineGap);
1024                     } else {
1025                         x = lineGap + j * (squareSize + lineGap);
1026                         y = lineGap + ((BOARD_HEIGHT-1)-i) *
1027                           (squareSize + lineGap);
1028                     }
1029                     if(damage[nr][i][j] & 2) // damage by old or new arrow
1030                         GraphExpose(currBoard, x - lineGap, y - lineGap, squareSize + 2*lineGap, squareSize  + 2*lineGap);
1031                     else
1032                         GraphExpose(currBoard, x, y, squareSize, squareSize);
1033                     damage[nr][i][j] &= 2; // remember damage by newly drawn error in '2' bit, to schedule it for erasure next draw
1034                 }
1035     }
1036
1037     FlashDelay(0); // this flushes drawing queue;
1038     if(nr) SwitchWindow(1);
1039 }
1040
1041 /* [AS] Arrow highlighting support */
1042
1043 static double A_WIDTH = 5; /* Width of arrow body */
1044
1045 #define A_HEIGHT_FACTOR 6   /* Length of arrow "point", relative to body width */
1046 #define A_WIDTH_FACTOR  3   /* Width of arrow "point", relative to body width */
1047
1048 static double
1049 Sqr (double x)
1050 {
1051     return x*x;
1052 }
1053
1054 static int
1055 Round (double x)
1056 {
1057     return (int) (x + 0.5);
1058 }
1059
1060 void
1061 SquareToPos (int rank, int file, int *x, int *y)
1062 {
1063     if (flipView) {
1064         *x = lineGap + ((BOARD_WIDTH-1)-file) * (squareSize + lineGap);
1065         *y = lineGap + rank * (squareSize + lineGap);
1066     } else {
1067         *x = lineGap + file * (squareSize + lineGap);
1068         *y = lineGap + ((BOARD_HEIGHT-1)-rank) * (squareSize + lineGap);
1069     }
1070 }
1071
1072 /* Draw an arrow between two points using current settings */
1073 static void
1074 DrawArrowBetweenPoints (int s_x, int s_y, int d_x, int d_y)
1075 {
1076     Pnt arrow[8];
1077     double dx, dy, j, k, x, y;
1078
1079     if( d_x == s_x ) {
1080         int h = (d_y > s_y) ? +A_WIDTH*A_HEIGHT_FACTOR : -A_WIDTH*A_HEIGHT_FACTOR;
1081
1082         arrow[0].x = s_x + A_WIDTH + 0.5;
1083         arrow[0].y = s_y;
1084
1085         arrow[1].x = s_x + A_WIDTH + 0.5;
1086         arrow[1].y = d_y - h;
1087
1088         arrow[2].x = arrow[1].x + A_WIDTH*(A_WIDTH_FACTOR-1) + 0.5;
1089         arrow[2].y = d_y - h;
1090
1091         arrow[3].x = d_x;
1092         arrow[3].y = d_y;
1093
1094         arrow[5].x = arrow[1].x - 2*A_WIDTH + 0.5;
1095         arrow[5].y = d_y - h;
1096
1097         arrow[4].x = arrow[5].x - A_WIDTH*(A_WIDTH_FACTOR-1) + 0.5;
1098         arrow[4].y = d_y - h;
1099
1100         arrow[6].x = arrow[1].x - 2*A_WIDTH + 0.5;
1101         arrow[6].y = s_y;
1102     }
1103     else if( d_y == s_y ) {
1104         int w = (d_x > s_x) ? +A_WIDTH*A_HEIGHT_FACTOR : -A_WIDTH*A_HEIGHT_FACTOR;
1105
1106         arrow[0].x = s_x;
1107         arrow[0].y = s_y + A_WIDTH + 0.5;
1108
1109         arrow[1].x = d_x - w;
1110         arrow[1].y = s_y + A_WIDTH + 0.5;
1111
1112         arrow[2].x = d_x - w;
1113         arrow[2].y = arrow[1].y + A_WIDTH*(A_WIDTH_FACTOR-1) + 0.5;
1114
1115         arrow[3].x = d_x;
1116         arrow[3].y = d_y;
1117
1118         arrow[5].x = d_x - w;
1119         arrow[5].y = arrow[1].y - 2*A_WIDTH + 0.5;
1120
1121         arrow[4].x = d_x - w;
1122         arrow[4].y = arrow[5].y - A_WIDTH*(A_WIDTH_FACTOR-1) + 0.5;
1123
1124         arrow[6].x = s_x;
1125         arrow[6].y = arrow[1].y - 2*A_WIDTH + 0.5;
1126     }
1127     else {
1128         /* [AS] Needed a lot of paper for this! :-) */
1129         dy = (double) (d_y - s_y) / (double) (d_x - s_x);
1130         dx = (double) (s_x - d_x) / (double) (s_y - d_y);
1131
1132         j = sqrt( Sqr(A_WIDTH) / (1.0 + Sqr(dx)) );
1133
1134         k = sqrt( Sqr(A_WIDTH*A_HEIGHT_FACTOR) / (1.0 + Sqr(dy)) );
1135
1136         x = s_x;
1137         y = s_y;
1138
1139         arrow[0].x = Round(x - j);
1140         arrow[0].y = Round(y + j*dx);
1141
1142         arrow[1].x = Round(arrow[0].x + 2*j);   // [HGM] prevent width to be affected by rounding twice
1143         arrow[1].y = Round(arrow[0].y - 2*j*dx);
1144
1145         if( d_x > s_x ) {
1146             x = (double) d_x - k;
1147             y = (double) d_y - k*dy;
1148         }
1149         else {
1150             x = (double) d_x + k;
1151             y = (double) d_y + k*dy;
1152         }
1153
1154         x = Round(x); y = Round(y); // [HGM] make sure width of shaft is rounded the same way on both ends
1155
1156         arrow[6].x = Round(x - j);
1157         arrow[6].y = Round(y + j*dx);
1158
1159         arrow[2].x = Round(arrow[6].x + 2*j);
1160         arrow[2].y = Round(arrow[6].y - 2*j*dx);
1161
1162         arrow[3].x = Round(arrow[2].x + j*(A_WIDTH_FACTOR-1));
1163         arrow[3].y = Round(arrow[2].y - j*(A_WIDTH_FACTOR-1)*dx);
1164
1165         arrow[4].x = d_x;
1166         arrow[4].y = d_y;
1167
1168         arrow[5].x = Round(arrow[6].x - j*(A_WIDTH_FACTOR-1));
1169         arrow[5].y = Round(arrow[6].y + j*(A_WIDTH_FACTOR-1)*dx);
1170     }
1171
1172     DrawPolygon(arrow, 7);
1173 //    Polygon( hdc, arrow, 7 );
1174 }
1175
1176 static void
1177 ArrowDamage (int s_col, int s_row, int d_col, int d_row)
1178 {
1179     int hor, vert, i, n = partnerUp * twoBoards;
1180     hor = 64*s_col + 32; vert = 64*s_row + 32;
1181     for(i=0; i<= 64; i++) {
1182             damage[n][vert+6>>6][hor+6>>6] |= 2;
1183             damage[n][vert-6>>6][hor+6>>6] |= 2;
1184             damage[n][vert+6>>6][hor-6>>6] |= 2;
1185             damage[n][vert-6>>6][hor-6>>6] |= 2;
1186             hor += d_col - s_col; vert += d_row - s_row;
1187     }
1188 }
1189
1190 /* [AS] Draw an arrow between two squares */
1191 static void
1192 DrawArrowBetweenSquares (int s_col, int s_row, int d_col, int d_row)
1193 {
1194     int s_x, s_y, d_x, d_y;
1195
1196     if( s_col == d_col && s_row == d_row ) {
1197         return;
1198     }
1199
1200     /* Get source and destination points */
1201     SquareToPos( s_row, s_col, &s_x, &s_y);
1202     SquareToPos( d_row, d_col, &d_x, &d_y);
1203
1204     if( d_y > s_y ) {
1205         d_y += squareSize / 2 - squareSize / 4; // [HGM] round towards same centers on all sides!
1206     }
1207     else if( d_y < s_y ) {
1208         d_y += squareSize / 2 + squareSize / 4;
1209     }
1210     else {
1211         d_y += squareSize / 2;
1212     }
1213
1214     if( d_x > s_x ) {
1215         d_x += squareSize / 2 - squareSize / 4;
1216     }
1217     else if( d_x < s_x ) {
1218         d_x += squareSize / 2 + squareSize / 4;
1219     }
1220     else {
1221         d_x += squareSize / 2;
1222     }
1223
1224     s_x += squareSize / 2;
1225     s_y += squareSize / 2;
1226
1227     /* Adjust width */
1228     A_WIDTH = squareSize / 14.; //[HGM] make float
1229
1230     DrawArrowBetweenPoints( s_x, s_y, d_x, d_y );
1231     ArrowDamage(s_col, s_row, d_col, d_row);
1232 }
1233
1234 static Boolean
1235 IsDrawArrowEnabled ()
1236 {
1237     return (appData.highlightMoveWithArrow || twoBoards && partnerUp) && squareSize >= 32;
1238 }
1239
1240 static void
1241 DrawArrowHighlight (int fromX, int fromY, int toX,int toY)
1242 {
1243     if( IsDrawArrowEnabled() && fromX >= 0 && fromY >= 0 && toX >= 0 && toY >= 0)
1244         DrawArrowBetweenSquares(fromX, fromY, toX, toY);
1245 }