Improve variant recognition for enabling buttons (XB)
[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, 2014, 2015 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, x = toX, y = toY;
603   Pnt      start, finish, mid;
604   Pnt      frames[kFactor * 2 + 1];
605   int         nFrames, startColor, endColor;
606
607   if(killX >= 0 && IS_LION(board[fromY][fromX])) Roar();
608
609   /* Are we animating? */
610   if (!appData.animate || appData.blindfold)
611     return;
612
613   if(board[toY][toX] == WhiteRook && board[fromY][fromX] == WhiteKing ||
614      board[toY][toX] == BlackRook && board[fromY][fromX] == BlackKing ||
615      board[toY][toX] == WhiteKing && board[fromY][fromX] == WhiteRook || // [HGM] seirawan
616      board[toY][toX] == BlackKing && board[fromY][fromX] == BlackRook)
617         return; // [HGM] FRC: no animtion of FRC castlings, as to-square is not true to-square
618
619   if (fromY < 0 || fromX < 0 || toX < 0 || toY < 0) return;
620   piece = board[fromY][fromX];
621   if (piece >= EmptySquare) return;
622
623   if(killX >= 0) toX = killX, toY = killY; // [HGM] lion: first to kill square
624
625 again:
626
627 #if DONT_HOP
628   hop = FALSE;
629 #else
630   hop = abs(fromX-toX) == 1 && abs(fromY-toY) == 2 || abs(fromX-toX) == 2 && abs(fromY-toY) == 1;
631 #endif
632
633   ScreenSquare(fromX, fromY, &start, &startColor);
634   ScreenSquare(toX, toY, &finish, &endColor);
635
636   if (hop) {
637     /* Knight: make straight movement then diagonal */
638     if (abs(toY - fromY) < abs(toX - fromX)) {
639        mid.x = start.x + (finish.x - start.x) / 2;
640        mid.y = start.y;
641      } else {
642        mid.x = start.x;
643        mid.y = start.y + (finish.y - start.y) / 2;
644      }
645   } else {
646     mid.x = start.x + (finish.x - start.x) / 2;
647     mid.y = start.y + (finish.y - start.y) / 2;
648   }
649
650   /* Don't use as many frames for very short moves */
651   if (abs(toY - fromY) + abs(toX - fromX) <= 2)
652     Tween(&start, &mid, &finish, kFactor - 1, frames, &nFrames);
653   else
654     Tween(&start, &mid, &finish, kFactor, frames, &nFrames);
655   FrameSequence(Game, piece, startColor, &start, &finish, frames, nFrames);
656   if(Explode(board, fromX, fromY, toX, toY)) { // mark as damaged
657     int i,j;
658     for(i=0; i<BOARD_WIDTH; i++) for(j=0; j<BOARD_HEIGHT; j++)
659       if((i-toX)*(i-toX) + (j-toY)*(j-toY) < 6) damage[0][j][i] |=  1 + ((i-toX ^ j-toY) & 1);
660   }
661
662   /* Be sure end square is redrawn */
663   damage[0][toY][toX] |= True;
664
665   if(toX != x || toY != y) { fromX = toX; fromY = toY; toX = x; toY = y; goto again; } // second leg
666 }
667
668 void
669 ChangeDragPiece (ChessSquare piece)
670 {
671   anims[Player].dragPiece = piece;
672   SetDragPiece(Player, piece);
673   damage[0][fromY][fromX] = True;
674 }
675
676 void
677 DragPieceMove (int x, int y)
678 {
679     Pnt corner;
680
681     /* Are we animating? */
682     if (!appData.animateDragging || appData.blindfold)
683       return;
684
685     /* Sanity check */
686     if (! anims[Player].dragActive)
687       return;
688     /* Move piece, maintaining same relative position
689        of mouse within square    */
690     corner.x = x - anims[Player].mouseDelta.x;
691     corner.y = y - anims[Player].mouseDelta.y;
692     AnimationFrame(Player, &corner, anims[Player].dragPiece);
693 #if HIGHDRAG*0
694     if (appData.highlightDragging) {
695         int boardX, boardY;
696         BoardSquare(x, y, &boardX, &boardY);
697         SetHighlights(fromX, fromY, boardX, boardY);
698     }
699 #endif
700 }
701
702 void
703 DragPieceEnd (int x, int y)
704 {
705     int boardX, boardY, color;
706     Pnt corner;
707
708     /* Are we animating? */
709     if (!appData.animateDragging || appData.blindfold)
710       return;
711
712     /* Sanity check */
713     if (! anims[Player].dragActive)
714       return;
715     /* Last frame in sequence is square piece is
716        placed on, which may not match mouse exactly. */
717     BoardSquare(x, y, &boardX, &boardY);
718     ScreenSquare(boardX, boardY, &corner, &color);
719     EndAnimation(Player, &corner);
720
721     /* Be sure end square is redrawn */
722     damage[0][boardY][boardX] = True;
723
724     /* This prevents weird things happening with fast successive
725        clicks which on my Sun at least can cause motion events
726        without corresponding press/release. */
727     anims[Player].dragActive = False;
728 }
729
730 void
731 DragPieceBegin (int x, int y, Boolean instantly)
732 {
733     int  boardX, boardY, color;
734     Pnt corner;
735
736     /* Are we animating? */
737     if (!appData.animateDragging || appData.blindfold)
738       return;
739
740     /* Figure out which square we start in and the
741        mouse position relative to top left corner. */
742     BoardSquare(x, y, &boardX, &boardY);
743     anims[Player].startBoardX = boardX;
744     anims[Player].startBoardY = boardY;
745     ScreenSquare(boardX, boardY, &corner, &color);
746     anims[Player].startSquare  = corner;
747     anims[Player].startColor   = color;
748     /* As soon as we start dragging, the piece will jump slightly to
749        be centered over the mouse pointer. */
750     anims[Player].mouseDelta.x = squareSize/2;
751     anims[Player].mouseDelta.y = squareSize/2;
752     /* Initialise animation */
753     anims[Player].dragPiece = PieceForSquare(boardX, boardY);
754     /* Sanity check */
755     if (anims[Player].dragPiece >= 0 && anims[Player].dragPiece < EmptySquare) {
756         ChessSquare bgPiece = EmptySquare;
757         anims[Player].dragActive = True;
758         if(boardX == BOARD_RGHT+1 && PieceForSquare(boardX-1, boardY) > 1 ||
759            boardX == BOARD_LEFT-2 && PieceForSquare(boardX+1, boardY) > 1)
760             bgPiece = anims[Player].dragPiece;
761         if(gatingPiece != EmptySquare) bgPiece = gatingPiece;
762         BeginAnimation(Player, anims[Player].dragPiece, bgPiece, color, &corner);
763         /* Mark this square as needing to be redrawn. Note that
764            we don't remove the piece though, since logically (ie
765            as seen by opponent) the move hasn't been made yet. */
766         damage[0][boardY][boardX] = True;
767     } else {
768         anims[Player].dragActive = False;
769     }
770 }
771
772 /* Handle expose event while piece being dragged */
773
774 static void
775 DrawDragPiece ()
776 {
777   if (!anims[Player].dragActive || appData.blindfold)
778     return;
779
780   /* What we're doing: logically, the move hasn't been made yet,
781      so the piece is still in it's original square. But visually
782      it's being dragged around the board. So we erase the square
783      that the piece is on and draw it at the last known drag point. */
784   DrawOneSquare(anims[Player].startSquare.x, anims[Player].startSquare.y,
785                 EmptySquare, anims[Player].startColor, 0, NULL, NULL, 0);
786   AnimationFrame(Player, &anims[Player].prevFrame, anims[Player].dragPiece);
787   damage[0][anims[Player].startBoardY][anims[Player].startBoardX] = TRUE;
788 }
789
790 static void
791 DrawSquare (int row, int column, ChessSquare piece, int do_flash)
792 {
793     int square_color, x, y, align=0;
794     int i;
795     char tString[3], bString[2];
796     int flash_delay;
797
798     /* Calculate delay in milliseconds (2-delays per complete flash) */
799     flash_delay = 500 / appData.flashRate;
800
801     if (flipView) {
802         x = lineGap + ((BOARD_WIDTH-1)-column) *
803           (squareSize + lineGap);
804         y = lineGap + row * (squareSize + lineGap);
805     } else {
806         x = lineGap + column * (squareSize + lineGap);
807         y = lineGap + ((BOARD_HEIGHT-1)-row) *
808           (squareSize + lineGap);
809     }
810
811     square_color = SquareColor(row, column);
812
813     bString[1] = bString[0] = NULLCHAR;
814     if (appData.showCoords && row == (flipView ? BOARD_HEIGHT-1 : 0)
815                 && column >= BOARD_LEFT && column < BOARD_RGHT) {
816         bString[0] = 'a' + column - BOARD_LEFT;
817         align = 1; // coord in lower-right corner
818     }
819     if (appData.showCoords && column == (flipView ? BOARD_RGHT-1 : BOARD_LEFT)) {
820         snprintf(tString, 3, "%d", ONE - '0' + row);
821         align = 2; // coord in upper-left corner
822     }
823     if (column == (flipView ? BOARD_LEFT-1 : BOARD_RGHT) && piece > 1 ) {
824         snprintf(tString, 3, "%d", piece);
825         align = 3; // holdings count in upper-right corner
826     }
827     if (column == (flipView ? BOARD_RGHT : BOARD_LEFT-1) && piece > 1) {
828         snprintf(tString, 3, "%d", piece);
829         align = 4; // holdings count in upper-left corner
830     }
831     if(piece == DarkSquare) square_color = 2;
832     if(square_color == 2 || appData.blindfold) piece = EmptySquare;
833
834     if (do_flash && piece != EmptySquare && appData.flashCount > 0) {
835         for (i=0; i<appData.flashCount; ++i) {
836             DrawOneSquare(x, y, piece, square_color, 0, tString, bString, 0);
837             GraphExpose(currBoard, x, y, squareSize, squareSize);
838             FlashDelay(flash_delay);
839             DrawOneSquare(x, y, EmptySquare, square_color, 0, tString, bString, 0);
840             GraphExpose(currBoard, x, y, squareSize, squareSize);
841             FlashDelay(flash_delay);
842         }
843     }
844     DrawOneSquare(x, y, piece, square_color, partnerUp ? 0 : marker[row][column], tString, bString, align);
845 }
846
847 /* Returns 1 if there are "too many" differences between b1 and b2
848    (i.e. more than 1 move was made) */
849 static int
850 too_many_diffs (Board b1, Board b2)
851 {
852     int i, j;
853     int c = 0;
854
855     for (i=0; i<BOARD_HEIGHT; ++i) {
856         for (j=0; j<BOARD_WIDTH; ++j) {
857             if (b1[i][j] != b2[i][j]) {
858                 if (++c > 4)    /* Castling causes 4 diffs */
859                   return 1;
860             }
861         }
862     }
863     return 0;
864 }
865
866 /* Matrix describing castling maneuvers */
867 /* Row, ColRookFrom, ColKingFrom, ColRookTo, ColKingTo */
868 static int castling_matrix[4][5] = {
869     { 0, 0, 4, 3, 2 },          /* 0-0-0, white */
870     { 0, 7, 4, 5, 6 },          /* 0-0,   white */
871     { 7, 0, 4, 3, 2 },          /* 0-0-0, black */
872     { 7, 7, 4, 5, 6 }           /* 0-0,   black */
873 };
874
875 /* Checks whether castling occurred. If it did, *rrow and *rcol
876    are set to the destination (row,col) of the rook that moved.
877
878    Returns 1 if castling occurred, 0 if not.
879
880    Note: Only handles a max of 1 castling move, so be sure
881    to call too_many_diffs() first.
882    */
883 static int
884 check_castle_draw (Board newb, Board oldb, int *rrow, int *rcol)
885 {
886     int i, *r, j;
887     int match;
888
889     /* For each type of castling... */
890     for (i=0; i<4; ++i) {
891         r = castling_matrix[i];
892
893         /* Check the 4 squares involved in the castling move */
894         match = 0;
895         for (j=1; j<=4; ++j) {
896             if (newb[r[0]][r[j]] == oldb[r[0]][r[j]]) {
897                 match = 1;
898                 break;
899             }
900         }
901
902         if (!match) {
903             /* All 4 changed, so it must be a castling move */
904             *rrow = r[0];
905             *rcol = r[3];
906             return 1;
907         }
908     }
909     return 0;
910 }
911
912 void
913 DrawPosition (int repaint, Board board)
914 {
915     int i, j, do_flash, exposeAll = False;
916     static int lastFlipView = 0;
917     static int lastBoardValid[2] = {0, 0};
918     static Board lastBoard[2];
919     static char lastMarker[BOARD_RANKS][BOARD_FILES];
920     int rrow, rcol;
921     int nr = twoBoards*partnerUp;
922
923     if(DrawSeekGraph()) return; // [HGM] seekgraph: suppress any drawing if seek graph up
924
925     if (board == NULL) {
926         if (!lastBoardValid[nr]) return;
927         board = lastBoard[nr];
928     }
929     if (!lastBoardValid[nr] || (nr == 0 && lastFlipView != flipView)) {
930         MarkMenuItem("View.Flip View", flipView);
931     }
932
933     if(nr) { SlavePopUp(); SwitchWindow(0); } // [HGM] popup board if not yet popped up, and switch drawing to it.
934
935     /*
936      * It would be simpler to clear the window with XClearWindow()
937      * but this causes a very distracting flicker.
938      */
939
940     if (!repaint && lastBoardValid[nr] && (nr == 1 || lastFlipView == flipView)) {
941
942 //      if ( lineGap && IsDrawArrowEnabled())
943 //          DrawGrid();
944
945         /* If too much changes (begin observing new game, etc.), don't
946            do flashing */
947         do_flash = too_many_diffs(board, lastBoard[nr]) ? 0 : 1;
948
949         /* Special check for castling so we don't flash both the king
950            and the rook (just flash the king). */
951         if (do_flash) {
952             if (check_castle_draw(board, lastBoard[nr], &rrow, &rcol)) {
953                 /* Mark rook for drawing with NO flashing. */
954                 damage[nr][rrow][rcol] |= 1;
955             }
956         }
957
958         /* First pass -- Draw (newly) empty squares and repair damage.
959            This prevents you from having a piece show up twice while it
960            is flashing on its new square */
961         for (i = 0; i < BOARD_HEIGHT; i++)
962           for (j = 0; j < BOARD_WIDTH; j++)
963             if (((board[i][j] != lastBoard[nr][i][j] || !nr && marker[i][j] != lastMarker[i][j]) && board[i][j] == EmptySquare)
964                 || damage[nr][i][j]) {
965                 DrawSquare(i, j, board[i][j], 0);
966                 if(damage[nr][i][j] & 2) {
967                     drawHighlight(j, i, 0);   // repair arrow damage
968                     if(lineGap) damage[nr][i][j] = False; // this flushed the square as well
969                 } else damage[nr][i][j] = 1;  // mark for expose
970             }
971
972         /* Second pass -- Draw piece(s) in new position and flash them */
973         for (i = 0; i < BOARD_HEIGHT; i++)
974           for (j = 0; j < BOARD_WIDTH; j++)
975             if (board[i][j] != lastBoard[nr][i][j] || !nr && marker[i][j] != lastMarker[i][j]) {
976                 DrawSquare(i, j, board[i][j], do_flash);
977                 damage[nr][i][j] = 1; // mark for expose
978             }
979     } else {
980         if (lineGap > 0)
981           DrawGrid();
982
983         for (i = 0; i < BOARD_HEIGHT; i++)
984           for (j = 0; j < BOARD_WIDTH; j++) {
985               DrawSquare(i, j, board[i][j], 0);
986               damage[nr][i][j] = False;
987           }
988
989         exposeAll = True;
990     }
991
992     CopyBoard(lastBoard[nr], board);
993     lastBoardValid[nr] = 1;
994   if(nr == 0) { // [HGM] dual: no highlights on second board yet
995     lastFlipView = flipView;
996     for (i = 0; i < BOARD_HEIGHT; i++)
997         for (j = 0; j < BOARD_WIDTH; j++)
998             lastMarker[i][j] = marker[i][j];
999
1000     /* Draw highlights */
1001     if (pm1X >= 0 && pm1Y >= 0) {
1002       drawHighlight(pm1X, pm1Y, 2);
1003       if(lineGap) damage[nr][pm1Y][pm1X] = False;
1004     }
1005     if (pm2X >= 0 && pm2Y >= 0) {
1006       drawHighlight(pm2X, pm2Y, 2);
1007       if(lineGap) damage[nr][pm2Y][pm2X] = False;
1008     }
1009     if (hi1X >= 0 && hi1Y >= 0) {
1010       drawHighlight(hi1X, hi1Y, 1);
1011       if(lineGap) damage[nr][hi1Y][hi1X] = False;
1012     }
1013     if (hi2X >= 0 && hi2Y >= 0) {
1014       drawHighlight(hi2X, hi2Y, 1);
1015       if(lineGap) damage[nr][hi2Y][hi2X] = False;
1016     }
1017     DrawArrowHighlight(hi1X, hi1Y, hi2X, hi2Y);
1018   }
1019   else DrawArrowHighlight (board[EP_STATUS-3], board[EP_STATUS-4], board[EP_STATUS-1], board[EP_STATUS-2]);
1020
1021     /* If piece being dragged around board, must redraw that too */
1022     DrawDragPiece();
1023
1024     if(exposeAll)
1025         GraphExpose(currBoard, 0, 0, BOARD_WIDTH*(squareSize + lineGap) + lineGap, BOARD_HEIGHT*(squareSize + lineGap) + lineGap);
1026     else {
1027         for (i = 0; i < BOARD_HEIGHT; i++)
1028             for (j = 0; j < BOARD_WIDTH; j++)
1029                 if(damage[nr][i][j]) {
1030                     int x, y;
1031                     if (flipView) {
1032                         x = lineGap + ((BOARD_WIDTH-1)-j) *
1033                           (squareSize + lineGap);
1034                         y = lineGap + i * (squareSize + lineGap);
1035                     } else {
1036                         x = lineGap + j * (squareSize + lineGap);
1037                         y = lineGap + ((BOARD_HEIGHT-1)-i) *
1038                           (squareSize + lineGap);
1039                     }
1040                     if(damage[nr][i][j] & 2) // damage by old or new arrow
1041                         GraphExpose(currBoard, x - lineGap, y - lineGap, squareSize + 2*lineGap, squareSize  + 2*lineGap);
1042                     else
1043                         GraphExpose(currBoard, x, y, squareSize, squareSize);
1044                     damage[nr][i][j] &= 2; // remember damage by newly drawn error in '2' bit, to schedule it for erasure next draw
1045                 }
1046     }
1047
1048     FlashDelay(0); // this flushes drawing queue;
1049     if(nr) SwitchWindow(1);
1050 }
1051
1052 /* [AS] Arrow highlighting support */
1053
1054 static double A_WIDTH = 5; /* Width of arrow body */
1055
1056 #define A_HEIGHT_FACTOR 6   /* Length of arrow "point", relative to body width */
1057 #define A_WIDTH_FACTOR  3   /* Width of arrow "point", relative to body width */
1058
1059 static double
1060 Sqr (double x)
1061 {
1062     return x*x;
1063 }
1064
1065 static int
1066 Round (double x)
1067 {
1068     return (int) (x + 0.5);
1069 }
1070
1071 void
1072 SquareToPos (int rank, int file, int *x, int *y)
1073 {
1074     if (flipView) {
1075         *x = lineGap + ((BOARD_WIDTH-1)-file) * (squareSize + lineGap);
1076         *y = lineGap + rank * (squareSize + lineGap);
1077     } else {
1078         *x = lineGap + file * (squareSize + lineGap);
1079         *y = lineGap + ((BOARD_HEIGHT-1)-rank) * (squareSize + lineGap);
1080     }
1081 }
1082
1083 /* Draw an arrow between two points using current settings */
1084 static void
1085 DrawArrowBetweenPoints (int s_x, int s_y, int d_x, int d_y)
1086 {
1087     Pnt arrow[8];
1088     double dx, dy, j, k, x, y;
1089
1090     if( d_x == s_x ) {
1091         int h = (d_y > s_y) ? +A_WIDTH*A_HEIGHT_FACTOR : -A_WIDTH*A_HEIGHT_FACTOR;
1092
1093         arrow[0].x = s_x + A_WIDTH + 0.5;
1094         arrow[0].y = s_y;
1095
1096         arrow[1].x = s_x + A_WIDTH + 0.5;
1097         arrow[1].y = d_y - h;
1098
1099         arrow[2].x = arrow[1].x + A_WIDTH*(A_WIDTH_FACTOR-1) + 0.5;
1100         arrow[2].y = d_y - h;
1101
1102         arrow[3].x = d_x;
1103         arrow[3].y = d_y;
1104
1105         arrow[5].x = arrow[1].x - 2*A_WIDTH + 0.5;
1106         arrow[5].y = d_y - h;
1107
1108         arrow[4].x = arrow[5].x - A_WIDTH*(A_WIDTH_FACTOR-1) + 0.5;
1109         arrow[4].y = d_y - h;
1110
1111         arrow[6].x = arrow[1].x - 2*A_WIDTH + 0.5;
1112         arrow[6].y = s_y;
1113     }
1114     else if( d_y == s_y ) {
1115         int w = (d_x > s_x) ? +A_WIDTH*A_HEIGHT_FACTOR : -A_WIDTH*A_HEIGHT_FACTOR;
1116
1117         arrow[0].x = s_x;
1118         arrow[0].y = s_y + A_WIDTH + 0.5;
1119
1120         arrow[1].x = d_x - w;
1121         arrow[1].y = s_y + A_WIDTH + 0.5;
1122
1123         arrow[2].x = d_x - w;
1124         arrow[2].y = arrow[1].y + A_WIDTH*(A_WIDTH_FACTOR-1) + 0.5;
1125
1126         arrow[3].x = d_x;
1127         arrow[3].y = d_y;
1128
1129         arrow[5].x = d_x - w;
1130         arrow[5].y = arrow[1].y - 2*A_WIDTH + 0.5;
1131
1132         arrow[4].x = d_x - w;
1133         arrow[4].y = arrow[5].y - A_WIDTH*(A_WIDTH_FACTOR-1) + 0.5;
1134
1135         arrow[6].x = s_x;
1136         arrow[6].y = arrow[1].y - 2*A_WIDTH + 0.5;
1137     }
1138     else {
1139         /* [AS] Needed a lot of paper for this! :-) */
1140         dy = (double) (d_y - s_y) / (double) (d_x - s_x);
1141         dx = (double) (s_x - d_x) / (double) (s_y - d_y);
1142
1143         j = sqrt( Sqr(A_WIDTH) / (1.0 + Sqr(dx)) );
1144
1145         k = sqrt( Sqr(A_WIDTH*A_HEIGHT_FACTOR) / (1.0 + Sqr(dy)) );
1146
1147         x = s_x;
1148         y = s_y;
1149
1150         arrow[0].x = Round(x - j);
1151         arrow[0].y = Round(y + j*dx);
1152
1153         arrow[1].x = Round(arrow[0].x + 2*j);   // [HGM] prevent width to be affected by rounding twice
1154         arrow[1].y = Round(arrow[0].y - 2*j*dx);
1155
1156         if( d_x > s_x ) {
1157             x = (double) d_x - k;
1158             y = (double) d_y - k*dy;
1159         }
1160         else {
1161             x = (double) d_x + k;
1162             y = (double) d_y + k*dy;
1163         }
1164
1165         x = Round(x); y = Round(y); // [HGM] make sure width of shaft is rounded the same way on both ends
1166
1167         arrow[6].x = Round(x - j);
1168         arrow[6].y = Round(y + j*dx);
1169
1170         arrow[2].x = Round(arrow[6].x + 2*j);
1171         arrow[2].y = Round(arrow[6].y - 2*j*dx);
1172
1173         arrow[3].x = Round(arrow[2].x + j*(A_WIDTH_FACTOR-1));
1174         arrow[3].y = Round(arrow[2].y - j*(A_WIDTH_FACTOR-1)*dx);
1175
1176         arrow[4].x = d_x;
1177         arrow[4].y = d_y;
1178
1179         arrow[5].x = Round(arrow[6].x - j*(A_WIDTH_FACTOR-1));
1180         arrow[5].y = Round(arrow[6].y + j*(A_WIDTH_FACTOR-1)*dx);
1181     }
1182
1183     DrawPolygon(arrow, 7);
1184 //    Polygon( hdc, arrow, 7 );
1185 }
1186
1187 static void
1188 ArrowDamage (int s_col, int s_row, int d_col, int d_row)
1189 {
1190     int hor, vert, i, n = partnerUp * twoBoards;
1191     hor = 64*s_col + 32; vert = 64*s_row + 32;
1192     for(i=0; i<= 64; i++) {
1193             damage[n][vert+6>>6][hor+6>>6] |= 2;
1194             damage[n][vert-6>>6][hor+6>>6] |= 2;
1195             damage[n][vert+6>>6][hor-6>>6] |= 2;
1196             damage[n][vert-6>>6][hor-6>>6] |= 2;
1197             hor += d_col - s_col; vert += d_row - s_row;
1198     }
1199 }
1200
1201 /* [AS] Draw an arrow between two squares */
1202 static void
1203 DrawArrowBetweenSquares (int s_col, int s_row, int d_col, int d_row)
1204 {
1205     int s_x, s_y, d_x, d_y;
1206
1207     if( s_col == d_col && s_row == d_row ) {
1208         return;
1209     }
1210
1211     /* Get source and destination points */
1212     SquareToPos( s_row, s_col, &s_x, &s_y);
1213     SquareToPos( d_row, d_col, &d_x, &d_y);
1214
1215     if( d_y > s_y ) {
1216         d_y += squareSize / 2 - squareSize / 4; // [HGM] round towards same centers on all sides!
1217     }
1218     else if( d_y < s_y ) {
1219         d_y += squareSize / 2 + squareSize / 4;
1220     }
1221     else {
1222         d_y += squareSize / 2;
1223     }
1224
1225     if( d_x > s_x ) {
1226         d_x += squareSize / 2 - squareSize / 4;
1227     }
1228     else if( d_x < s_x ) {
1229         d_x += squareSize / 2 + squareSize / 4;
1230     }
1231     else {
1232         d_x += squareSize / 2;
1233     }
1234
1235     s_x += squareSize / 2;
1236     s_y += squareSize / 2;
1237
1238     /* Adjust width */
1239     A_WIDTH = squareSize / 14.; //[HGM] make float
1240
1241     DrawArrowBetweenPoints( s_x, s_y, d_x, d_y );
1242     ArrowDamage(s_col, s_row, d_col, d_row);
1243 }
1244
1245 static Boolean
1246 IsDrawArrowEnabled ()
1247 {
1248     return (appData.highlightMoveWithArrow || twoBoards && partnerUp) && squareSize >= 32;
1249 }
1250
1251 static void
1252 DrawArrowHighlight (int fromX, int fromY, int toX,int toY)
1253 {
1254     if( IsDrawArrowEnabled() && fromX >= 0 && fromY >= 0 && toX >= 0 && toY >= 0)
1255         DrawArrowBetweenSquares(fromX, fromY, toX, toY);
1256 }