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