?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Added configuration parameter 'engine_init' which sends a command to a
[cboard.git] / src / cboard.c
blobebfab54f4f21136f5b7875abb45b9c7ff8efbd4e
1 /* vim:tw=78:ts=8:sw=4:set ft=c: */
2 /*
3 Copyright (C) 2002-2006 Ben Kibbey <bjk@luxsci.net>
4
5 This program is free software; you can redistribute it and/or modify
6 it under the terms of the GNU General Public License as published by
7 the Free Software Foundation; either version 2 of the License, or
8 (at your option) any later version.
9
10 This program is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 GNU General Public License for more details.
14
15 You should have received a copy of the GNU General Public License
16 along with this program; if not, write to the Free Software
17 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
18 */
19 #include <stdio.h>
20 #include <stdlib.h>
21 #include <unistd.h>
22 #include <err.h>
23 #include <sys/types.h>
24 #include <sys/time.h>
25 #include <sys/socket.h>
26 #include <sys/stat.h>
27 #include <string.h>
28 #include <panel.h>
29 #include <errno.h>
30 #include <ctype.h>
31 #include <pwd.h>
32 #include <signal.h>
33 #include <time.h>
34
35 #ifdef HAVE_CONFIG_H
36 #include <config.h>
37 #endif
38
39 #ifdef HAVE_WORDEXP_H
40 #include <wordexp.h>
41 #endif
42
43 #ifdef HAVE_DIRENT_H
44 #include <dirent.h>
45 #endif
46
47 #ifdef HAVE_MENU_H
48 #include <menu.h>
49 #endif
50
51 #ifdef HAVE_REGEX_H
52 #include <regex.h>
53 #endif
54
55 #include "chess.h"
56 #include "conf.h"
57 #include "window.h"
58 #include "colors.h"
59 #include "input.h"
60 #include "misc.h"
61 #include "engine.h"
62 #include "rcfile.h"
63 #include "strings.h"
64 #include "common.h"
65 #include "cboard.h"
66
67 #ifdef DEBUG
68 #include "debug.h"
69 #endif
70
71 #ifdef WITH_DMALLOC
72 #include <dmalloc.h>
73 #endif
74
75 static char *str_etc(const char *str, int maxlen, int rev)
76 {
77 int len = strlen(str);
78 static char buf[80], *p = buf;
79 int i;
80
81 strncpy(buf, str, sizeof(buf));
82
83 if (len > maxlen) {
84 if (rev) {
85 p = buf;
86 *p++ = '.';
87 *p++ = '.';
88 *p++ = '.';
89
90 for (i = 0; i < maxlen + 3; i++)
91 *p++ = buf[(len - maxlen) + i + 3];
92 }
93 else {
94 p = buf + maxlen - 4;
95 *p++ = '.';
96 *p++ = '.';
97 *p++ = '.';
98 }
99
100 *p = '\0';
101 }
102
103 return buf;
104 }
105
106 /* FIXME castling */
107 void update_cursor(GAME g, int idx)
108 {
109 char *p;
110 int len;
111 int t = history_total(g.hp);
112
113 /*
114 * If not deincremented then r and c would be the next move.
115 */
116 idx--;
117
118 if (idx > t || idx < 0 || !t || !g.hp[idx]->move) {
119 c_row = 2, c_col = 5;
120 return;
121 }
122
123 p = g.hp[idx]->move;
124 len = strlen(p);
125
126 if (*p == 'O') {
127 if (len <= 4)
128 c_col = 7;
129 else
130 c_col = 3;
131
132 c_row = (g.turn == WHITE) ? 8 : 1;
133 return;
134 }
135
136 p += len;
137
138 while (!isdigit(*p))
139 p--;
140
141 c_row = ROWTOINT(*p--);
142 c_col = COLTOINT(*p);
143 }
144
145 static int init_nag()
146 {
147 FILE *fp;
148 char line[LINE_MAX];
149 int i = 0;
150
151 if ((fp = fopen(config.nagfile, "r")) == NULL) {
152 cmessage(ERROR, ANYKEY, "%s: %s", config.nagfile, strerror(errno));
153 return 1;
154 }
155
156 while (!feof(fp)) {
157 if (fscanf(fp, " %[^\n] ", line) == 1) {
158 nags = Realloc(nags, (i + 2) * sizeof(struct nag_s));
159 nags[i].line = strdup(line);
160 i++;
161 }
162 }
163
164 if (nags)
165 nags[i].line = NULL;
166 return 0;
167 }
168
169 char *history_edit_nag(void *arg)
170 {
171 WINDOW *win, *subw;
172 PANEL *panel;
173 ITEM **mitems = NULL;
174 MENU *menu;
175 int i = 0, n;
176 int itemcount = 0;
177 int rows, cols;
178 char *mbuf = NULL;
179 HISTORY *anno = (HISTORY *)arg;
180
181 if (!nags) {
182 if (init_nag())
183 return NULL;
184 }
185
186 i = 0;
187 mitems = Realloc(mitems, (i + 2) * sizeof(ITEM));
188 mitems[i++] = new_item(NONE, NULL);
189
190 for (n = 0; nags[n].line; n++, i++) {
191 mitems = Realloc(mitems, (i + 2) * sizeof(ITEM));
192 mitems[i] = new_item(nags[n].line, NULL);
193 }
194
195 mitems[i] = NULL;
196 menu = new_menu(mitems);
197 scale_menu(menu, &rows, &cols);
198
199 win = newwin(rows + 4, cols + 2, CALCPOSY(rows) - 2, CALCPOSX(cols));
200 set_menu_win(menu, win);
201 subw = derwin(win, rows, cols, 2, 1);
202 set_menu_sub(menu, subw);
203 set_menu_fore(menu, A_REVERSE);
204 set_menu_grey(menu, A_NORMAL);
205 set_menu_mark(menu, NULL);
206 set_menu_spacing(menu, 0, 0, 0);
207 menu_opts_off(menu, O_NONCYCLIC|O_SHOWDESC|O_ONEVALUE);
208 post_menu(menu);
209 panel = new_panel(win);
210 cbreak();
211 noecho();
212 keypad(win, TRUE);
213 set_menu_pattern(menu, mbuf);
214 wbkgd(win, CP_MESSAGE_WINDOW);
215 draw_window_title(win, NAG_EDIT_TITLE, cols + 2, CP_HISTORY_TITLE,
216 CP_HISTORY_BORDER);
217
218 for (i = 0; i < MAX_PGN_NAG; i++) {
219 if (anno->nag[i] && anno->nag[i] <= item_count(menu)) {
220 set_item_value(mitems[anno->nag[i]], TRUE);
221 set_current_item(menu, mitems[anno->nag[i]]);
222 itemcount++;
223 }
224 }
225
226 while (1) {
227 int c;
228 char *tmp;
229 char buf[cols - 4];
230
231 wattron(win, A_REVERSE);
232
233 for (c = 1; c < (cols + 2) - 1; c++)
234 mvwprintw(win, rows + 2, c, " ");
235
236 c = item_index(current_item(menu)) + 1;
237
238 snprintf(buf, sizeof(buf), "Item %i of %i (%i of %i selected) %s", c,
239 item_count(menu), itemcount, MAX_PGN_NAG, NAG_EDIT_PROMPT);
240 draw_prompt(win, rows + 2, cols + 2, buf, CP_MESSAGE_PROMPT);
241
242 wattroff(win, A_REVERSE);
243
244 if (!itemcount) {
245 for (i = 0; mitems[i]; i++)
246 set_item_value(mitems[i], FALSE);
247
248 set_item_value(mitems[0], TRUE);
249 }
250 else
251 set_item_value(mitems[0], FALSE);
252
253 /* This nl() statement needs to be here because NL is recognized
254 * for some reason after the first selection.
255 */
256 nl();
257 refresh_all();
258 c = wgetch(win);
259
260 switch (c) {
261 int found;
262
263 case KEY_F(1):
264 help(NAG_EDIT_HELP, ANYKEY, naghelp);
265 break;
266 case KEY_RIGHT:
267 if (!itemcount)
268 break;
269
270 found = 0;
271
272 for (i = item_index(current_item(menu)) + 1; mitems[i]; i++) {
273 if (item_value(mitems[i]) == TRUE) {
274 found = i;
275 break;
276 }
277 }
278
279 if (!found) {
280 for (i = 0; mitems[i]; i++) {
281 if (item_value(mitems[i]) == TRUE) {
282 found = i;
283 break;
284 }
285 }
286 }
287
288 set_current_item(menu, mitems[found]);
289 break;
290 case KEY_LEFT:
291 if (!itemcount)
292 break;
293
294 found = 0;
295
296 for (i = item_index(current_item(menu)) - 1; i > 0; i--) {
297 if (item_value(mitems[i]) == TRUE) {
298 found = i;
299 break;
300 }
301 }
302
303 if (!found) {
304 for (i = item_count(menu) - 1; i > 0; i--) {
305 if (item_value(mitems[i]) == TRUE) {
306 found = i;
307 break;
308 }
309 }
310 }
311
312 set_current_item(menu, mitems[found]);
313 break;
314 case KEY_HOME:
315 menu_driver(menu, REQ_FIRST_ITEM);
316 break;
317 case KEY_END:
318 menu_driver(menu, REQ_LAST_ITEM);
319 break;
320 case KEY_UP:
321 menu_driver(menu, REQ_UP_ITEM);
322 break;
323 case KEY_DOWN:
324 menu_driver(menu, REQ_DOWN_ITEM);
325 break;
326 case KEY_PPAGE:
327 case CTRL('P'):
328 if (menu_driver(menu, REQ_SCR_UPAGE) == E_REQUEST_DENIED)
329 menu_driver(menu, REQ_FIRST_ITEM);
330 break;
331 case KEY_NPAGE:
332 case CTRL('N'):
333 if (menu_driver(menu, REQ_SCR_DPAGE) == E_REQUEST_DENIED)
334 menu_driver(menu, REQ_LAST_ITEM);
335 break;
336 case ' ':
337 if (item_index(current_item(menu)) == 0 &&
338 item_value(current_item(menu)) == FALSE) {
339 itemcount = 0;
340 break;
341 }
342
343 if (item_value(current_item(menu)) == TRUE) {
344 set_item_value(current_item(menu), FALSE);
345 itemcount--;
346 }
347 else {
348 if (itemcount + 1 > MAX_PGN_NAG)
349 break;
350
351 set_item_value(current_item(menu), TRUE);
352 itemcount++;
353 }
354
355 SET_FLAG(game[gindex].flags, GF_MODIFIED);
356 break;
357 case '\n':
358 goto gotitem;
359 break;
360 case KEY_ESCAPE:
361 goto done;
362 break;
363 default:
364 tmp = menu_pattern(menu);
365
366 if (tmp && tmp[strlen(tmp) - 1] != c) {
367 menu_driver(menu, REQ_CLEAR_PATTERN);
368 menu_driver(menu, c);
369 }
370 else {
371 if (menu_driver(menu, REQ_NEXT_MATCH) == E_NO_MATCH)
372 menu_driver(menu, c);
373 }
374
375 break;
376 }
377 }
378
379 gotitem:
380 for (i = 0; i < MAX_PGN_NAG; i++)
381 anno->nag[i] = 0;
382
383 for (i = 0, n = 0; mitems[i] && n < MAX_PGN_NAG; i++) {
384 if (item_value(mitems[i]) == TRUE)
385 anno->nag[n++] = i;
386 }
387
388 done:
389 unpost_menu(menu);
390 free_menu(menu);
391
392 for (i = 0; mitems[i]; i++)
393 free_item(mitems[i]);
394
395 free(mitems);
396 del_panel(panel);
397 delwin(subw);
398 delwin(win);
399 return NULL;
400 }
401
402 static void view_nag(void *arg)
403 {
404 HISTORY *h = (HISTORY *)arg;
405 char buf[80];
406 char line[LINE_MAX] = {0};
407 int i = 0;
408
409 snprintf(buf, sizeof(buf), "Viewing NAG for \"%s\"", h->move);
410
411 if (!nags) {
412 if (init_nag())
413 return;
414 }
415
416 for (i = 0; i < MAX_PGN_NAG; i++) {
417 if (!h->nag[i])
418 break;
419
420 strncat(line, nags[h->nag[i] - 1].line, sizeof(line));
421 strncat(line, "\n", sizeof(line));
422 }
423
424 line[strlen(line) - 1] = 0;
425 message(buf, ANYKEY, "%s", line);
426 }
427
428 void view_annotation(HISTORY h)
429 {
430 char buf[MAX_SAN_MOVE_LEN + strlen(ANNOTATION_VIEW_TITLE) + 4];
431 int nag = 0, comment = 0;
432
433 if (h.comment && h.comment[0])
434 comment++;
435
436 if (h.nag[0])
437 nag++;
438
439 if (!nag && !comment)
440 return;
441
442 snprintf(buf, sizeof(buf), "%s \"%s\"", ANNOTATION_VIEW_TITLE, h.move);
443
444 if (comment)
445 show_message(buf, (nag) ? "Any other key to continue" : ANYKEY,
446 (nag) ? "Press 'n' to view NAG" : NULL,
447 (nag) ? view_nag : NULL, (nag) ? (void *)&h : NULL,
448 (nag) ? 'n' : 0, "%s", h.comment);
449 else
450 show_message(buf, "Any other key to continue", "Press 'n' to view NAG",
451 view_nag, (void *)&h, 'n', "%s", "No annotations for this move");
452 }
453
454 static void cleanup(WINDOW *win, WINDOW *subw, PANEL *panel, MENU *menu,
455 ITEM **items, struct d_entries *entries)
456 {
457 int i;
458
459 unpost_menu(menu);
460 free_menu(menu);
461
462 for (i = 0; items[i]; i++)
463 free_item(items[i]);
464
465 free(items);
466
467 if (entries) {
468 for (i = 0; entries[i].name; i++) {
469 free(entries[i].name);
470 free(entries[i].fancy);
471 }
472
473 free(entries);
474 }
475
476 del_panel(panel);
477 delwin(subw);
478 delwin(win);
479 }
480
481 static int sort_entries(const void *s1, const void *s2)
482 {
483 const struct d_entries *ss1 = s1;
484 const struct d_entries *ss2 = s2;
485
486 return strcmp(ss1->name, ss2->name);
487 }
488
489 char *browse_directory(void *arg)
490 {
491 char *inputstr = (char *)arg;
492 int initkey = (inputstr) ? inputstr[0] : 0;
493 char pattern[FILENAME_MAX];
494 static char path[FILENAME_MAX];
495 static char file[FILENAME_MAX];
496 struct stat st;
497 char *p;
498
499 if (!*path) {
500 if (config.savedirectory) {
501 if ((p = word_expand(config.savedirectory)) == NULL)
502 return NULL;
503
504 strncpy(path, p, sizeof(path));
505
506 if (access(path, R_OK) == -1) {
507 cmessage(ERROR, ANYKEY, "%s: %s", path, strerror(errno));
508 getcwd(path, sizeof(path));
509 }
510 }
511 else
512 getcwd(path, sizeof(path));
513 }
514
515 again:
516 /*
517 * First find directories (including hidden) in the working directory.
518 * Then apply the config.pattern to regular files.
519 */
520 if ((p = word_split_append(path, '/', ".* *")) == NULL)
521 return NULL;
522
523 strncpy(pattern, p, sizeof(pattern));
524
525 while (1) {
526 WINDOW *win, *subw;
527 PANEL *panel;
528 ITEM **mitems = NULL;
529 MENU *menu;
530 char *tmp = NULL;
531 int rows, cols;
532 int selected = -1;
533 char *mbuf = NULL;
534 int idx = 0;
535 int len = strlen(path);
536 wordexp_t w;
537 int i, n = 0;
538 struct d_entries *entries = NULL;
539 int which = 1;
540 int x = WRDE_NOCMD;
541
542 new_we:
543 if (wordexp(pattern, &w, x) != 0) {
544 cmessage(ERROR, ANYKEY, "Error in pattern\n%s", pattern);
545 return NULL;
546 }
547
548 for (i = 0; i < w.we_wordc; i++) {
549 struct tm *tp;
550 char tbuf[16];
551
552 if (stat(w.we_wordv[i], &st) == -1)
553 continue;
554
555 if ((p = strrchr(w.we_wordv[i], '/')) != NULL)
556 p++;
557 else
558 p = w.we_wordv[i];
559
560 if (which) {
561 if (!S_ISDIR(st.st_mode))
562 continue;
563
564 if (p[0] == '.' && p[1] == 0)
565 continue;
566 }
567 else {
568 if (S_ISDIR(st.st_mode))
569 continue;
570 }
571
572 len = strlen(p) + 2;
573 entries = Realloc(entries, (n + 2) * sizeof(struct d_entries));
574 entries[n].name = strdup(w.we_wordv[i]);
575 entries[n].fancy = Malloc(len);
576 strncpy(entries[n].fancy, p, len);
577
578 if (S_ISDIR(st.st_mode))
579 entries[n].fancy[len - 2] = '/';
580
581 tp = localtime(&st.st_mtime);
582 strftime(tbuf, sizeof(tbuf), "%b %d %T", tp);
583
584 snprintf(entries[n].desc, sizeof(entries[n].desc), "%-7i %s",
585 (int)st.st_size, tbuf);
586
587 memset(&entries[++n], '\0', sizeof(struct d_entries));
588 }
589
590 which--;
591
592 if (which == 0) {
593 if ((p = word_split_append(path, '/', config.pattern)) == NULL)
594 return NULL;
595
596 strncpy(pattern, p, sizeof(pattern));
597 x |= WRDE_REUSE;
598 goto new_we;
599 }
600
601 wordfree(&w);
602 qsort(entries, n, sizeof(struct d_entries), sort_entries);
603
604 for (i = 0; i < n; i++) {
605 mitems = Realloc(mitems, (idx + 2) * sizeof(ITEM));
606 mitems[idx++] = new_item(entries[i].fancy, entries[i].desc);
607 }
608
609 mitems[idx] = NULL;
610 menu = new_menu(mitems);
611 scale_menu(menu, &rows, &cols);
612
613 if (cols < strlen(path))
614 cols = strlen(path);
615
616 if (cols < strlen(HELP_PROMPT))
617 cols = strlen(HELP_PROMPT);
618
619 rows = (LINES / 5) * 4;
620 cols += 2;
621
622 win = newwin(rows + 4, cols, CALCPOSY(rows) - 2, CALCPOSX(cols));
623 set_menu_format(menu, rows, 0);
624 set_menu_win(menu, win);
625 subw = derwin(win, rows, cols - 2, 2, 1);
626 set_menu_sub(menu, subw);
627 set_menu_fore(menu, A_REVERSE);
628 set_menu_grey(menu, A_NORMAL);
629 set_menu_mark(menu, NULL);
630 set_menu_spacing(menu, 2, 0, 0);
631 menu_opts_off(menu, O_NONCYCLIC);
632 post_menu(menu);
633 panel = new_panel(win);
634
635 draw_window_title(win, path, cols, CP_MESSAGE_TITLE, CP_MESSAGE_BORDER);
636 draw_prompt(win, rows + 2, cols, HELP_PROMPT, CP_MESSAGE_PROMPT);
637
638 cbreak();
639 noecho();
640 keypad(win, TRUE);
641 set_menu_pattern(menu, mbuf);
642
643 if (isgraph(initkey)) {
644 menu_driver(menu, initkey);
645 initkey = '\0';
646 }
647
648 while (1) {
649 int c;
650
651 /* This nl() statement needs to be here because NL is recognized
652 * for some reason after the first selection.
653 */
654 nl();
655 refresh_all();
656 c = wgetch(win);
657
658 switch (c) {
659 case CTRL('P'):
660 case KEY_PPAGE:
661 menu_driver(menu, REQ_SCR_UPAGE);
662 break;
663 case ' ':
664 case CTRL('N'):
665 case KEY_NPAGE:
666 menu_driver(menu, REQ_SCR_DPAGE);
667 break;
668 case KEY_UP:
669 menu_driver(menu, REQ_UP_ITEM);
670 break;
671 case KEY_DOWN:
672 menu_driver(menu, REQ_DOWN_ITEM);
673 break;
674 case '\n':
675 selected = item_index(current_item(menu));
676 goto gotitem;
677 break;
678 case KEY_ESCAPE:
679 cleanup(win, subw, panel, menu, mitems, entries);
680 file[0] = 0;
681 goto done;
682 break;
683 case KEY_F(1):
684 help(BROWSER_HELP, ANYKEY, file_browser_help);
685 break;
686 case '~':
687 strncpy(path, "~/", sizeof(path));
688 cleanup(win, subw, panel, menu, mitems, entries);
689 goto again;
690 break;
691 case CTRL('X'):
692 if ((tmp = get_input_str_clear(BROWSER_CHDIR_TITLE, NULL))
693 == NULL)
694 break;
695
696 strncpy(path, tmp, sizeof(path));
697 cleanup(win, subw, panel, menu, mitems, entries);
698 goto again;
699 break;
700 default:
701 tmp = menu_pattern(menu);
702
703 if (tmp && tmp[strlen(tmp) - 1] != c) {
704 menu_driver(menu, REQ_CLEAR_PATTERN);
705 menu_driver(menu, c);
706 }
707 else {
708 if (menu_driver(menu, REQ_NEXT_MATCH) == E_NO_MATCH)
709 menu_driver(menu, c);
710 }
711
712 break;
713 }
714 }
715
716 gotitem:
717 strncpy(file, entries[selected].name, sizeof(file));
718 cleanup(win, subw, panel, menu, mitems, entries);
719
720 if (stat(file, &st) == -1) {
721 cmessage(ERROR, ANYKEY, "%s\n%s", file, strerror(errno));
722 continue;
723 }
724
725 if (S_ISDIR(st.st_mode)) {
726 p = file + strlen(file) - 2;
727
728 if (strcmp(p, "..") == 0) {
729 p = file + strlen(file) - 3;
730 *p = 0;
731
732 if ((p = strrchr(file, '/')) != NULL)
733 file[strlen(file) - strlen(p)] = 0;
734 }
735
736 strncpy(path, file, sizeof(path));
737 goto again;
738 }
739
740 if (S_ISREG(st.st_mode))
741 break;
742
743 cmessage(ERROR, ANYKEY, "%s\n%s", file, E_NOTAREGFILE);
744 }
745
746 done:
747 return (*file) ? file : NULL;
748 }
749 static int init_country_codes()
750 {
751 FILE *fp;
752 char line[LINE_MAX], *s;
753 int cindex = 0;
754
755 if ((fp = fopen(config.ccfile, "r")) == NULL) {
756 cmessage(ERROR, ANYKEY, "%s: %s", config.ccfile, strerror(errno));
757 return 1;
758 }
759
760 while ((s = fgets(line, sizeof(line), fp)) != NULL) {
761 char *tmp;
762
763 if ((tmp = strsep(&s, " ")) == NULL)
764 continue;
765
766 s = trim(s);
767 tmp = trim(tmp);
768
769 if (!s || !tmp)
770 continue;
771
772 ccodes = Realloc(ccodes, (cindex + 2) * sizeof(struct country_codes));
773 strncpy(ccodes[cindex].code, tmp, sizeof(ccodes[cindex].code));
774 strncpy(ccodes[cindex].country, s, sizeof(ccodes[cindex].country));
775 cindex++;
776 }
777
778 memset(&ccodes[cindex], '\0', sizeof(struct country_codes));
779 fclose(fp);
780
781 return 0;
782 }
783
784 char *country_codes(void *arg)
785 {
786 WINDOW *win, *subw;
787 PANEL *panel;
788 ITEM **mitems = NULL;
789 MENU *menu;
790 int i = 0, n;
791 int rows, cols;
792 char *mbuf = NULL;
793 char *tmp = NULL;
794
795 if (!ccodes) {
796 if (init_country_codes())
797 return NULL;
798 }
799
800 for (n = i = 0; ccodes[n].code[0]; n++, i++) {
801 mitems = Realloc(mitems, (i + 2) * sizeof(ITEM));
802 mitems[i] = new_item(ccodes[n].country, ccodes[n].code);
803 }
804
805 mitems[i] = NULL;
806 menu = new_menu(mitems);
807 scale_menu(menu, &rows, &cols);
808
809 if (cols < strlen(HELP_PROMPT) + 21)
810 cols = strlen(HELP_PROMPT) + 21;
811
812 win = newwin(rows + 4, cols + 4, CALCPOSY(rows) - 2, CALCPOSX(cols));
813 set_menu_win(menu, win);
814 subw = derwin(win, rows, cols + 2, 2, 1);
815 set_menu_sub(menu, subw);
816 set_menu_fore(menu, A_REVERSE);
817 set_menu_grey(menu, A_NORMAL);
818 set_menu_mark(menu, NULL);
819 set_menu_spacing(menu, 0, 0, 0);
820 menu_opts_off(menu, O_NONCYCLIC);
821 post_menu(menu);
822 panel = new_panel(win);
823 cbreak();
824 noecho();
825 keypad(win, TRUE);
826 set_menu_pattern(menu, mbuf);
827 wbkgd(win, CP_MESSAGE_WINDOW);
828 draw_window_title(win, CC_TITLE, cols + 4, CP_MESSAGE_TITLE,
829 CP_MESSAGE_BORDER);
830
831 while (1) {
832 int c;
833 char buf[cols - 4];
834
835 wattron(win, A_REVERSE);
836
837 for (c = 1; c < (cols + 2) - 1; c++)
838 mvwprintw(win, rows + 2, c, " ");
839
840 c = item_index(current_item(menu)) + 1;
841
842 snprintf(buf, sizeof(buf), "%s %i %s %i %s", MENU_ITEM_STR, c,
843 N_OF_N_STR, item_count(menu), HELP_PROMPT);
844 draw_prompt(win, rows + 2, cols + 2, buf, CP_MESSAGE_PROMPT);
845
846 wattroff(win, A_REVERSE);
847
848 /* This nl() statement needs to be here because NL is recognized
849 * for some reason after the first selection.
850 */
851 nl();
852 refresh_all();
853 c = wgetch(win);
854
855 switch (c) {
856 case KEY_F(1):
857 help(CC_KEY_HELP, ANYKEY, cc_help);
858 break;
859 case KEY_HOME:
860 menu_driver(menu, REQ_FIRST_ITEM);
861 break;
862 case KEY_END:
863 menu_driver(menu, REQ_LAST_ITEM);
864 break;
865 case KEY_UP:
866 menu_driver(menu, REQ_UP_ITEM);
867 break;
868 case KEY_DOWN:
869 menu_driver(menu, REQ_DOWN_ITEM);
870 break;
871 case KEY_PPAGE:
872 case CTRL('P'):
873 if (menu_driver(menu, REQ_SCR_UPAGE) == E_REQUEST_DENIED)
874 menu_driver(menu, REQ_FIRST_ITEM);
875 break;
876 case ' ':
877 case KEY_NPAGE:
878 case CTRL('N'):
879 if (menu_driver(menu, REQ_SCR_DPAGE) == E_REQUEST_DENIED)
880 menu_driver(menu, REQ_LAST_ITEM);
881 break;
882 case '\n':
883 tmp = (char *)item_description(current_item(menu));
884 goto done;
885 break;
886 case KEY_ESCAPE:
887 tmp = NULL;
888 goto done;
889 break;
890 default:
891 tmp = menu_pattern(menu);
892
893 if (tmp && tmp[strlen(tmp) - 1] != c) {
894 menu_driver(menu, REQ_CLEAR_PATTERN);
895 menu_driver(menu, c);
896 }
897 else {
898 if (menu_driver(menu, REQ_NEXT_MATCH) == E_NO_MATCH)
899 menu_driver(menu, c);
900 }
901
902 break;
903 }
904 }
905
906 done:
907 unpost_menu(menu);
908 free_menu(menu);
909
910 for (i = 0; mitems[i]; i++)
911 free_item(mitems[i]);
912
913 del_panel(panel);
914 delwin(subw);
915 delwin(win);
916 return tmp;
917 }
918
919 static void add_custom_tags(TAG ***t)
920 {
921 int i;
922
923 if (!config.tag)
924 return;
925
926 for (i = 0; config.tag[i]; i++)
927 pgn_add_tag(t, config.tag[i]->name, config.tag[i]->value);
928
929 pgn_sort_tags(*t);
930 }
931
932 TAG **edit_tags(GAME g, BOARD b, int edit)
933 {
934 TAG **data = NULL;
935 struct tm tp;
936 unsigned char data_index = 0;
937 int n, lastindex = 0;
938 int len;
939
940 /* Edit the backup copy, not the original in case the save fails. */
941 for (n = 0; g.tag[n]; n++)
942 pgn_add_tag(&data, g.tag[n]->name, g.tag[n]->value);
943
944 data_index = pgn_tag_total(data);
945
946 while (1) {
947 WINDOW *win, *subw;
948 PANEL *panel;
949 ITEM **mitems = NULL;
950 MENU *menu;
951 int i;
952 char buf[76] = {0};
953 char *tmp = NULL;
954 int rows, cols;
955 int selected = -1;
956 char *mbuf = NULL;
957 int nlen = 0, vlen = 0;
958
959 data_index = pgn_tag_total(data);
960
961 for (i = 0; i < data_index; i++) {
962 mitems = Realloc(mitems, (i + 2) * sizeof(ITEM));
963
964 if (data[i]->value) {
965 nlen = strlen(data[i]->name);
966 vlen = strlen(data[i]->value);
967
968 /* The +6 is for the menu padding. */
969 mitems[i] = new_item(data[i]->name,
970 (nlen + vlen + 6 >= MAX_VALUE_WIDTH)
971 ? PRESS_ENTER : data[i]->value);
972 }
973 else
974 mitems[i] = new_item(data[i]->name, UNKNOWN);
975 }
976
977 mitems[i] = NULL;
978 menu = new_menu(mitems);
979 scale_menu(menu, &rows, &cols);
980
981 /* +14 for the extra prompt info. */
982 if (cols < strlen(HELP_PROMPT) + 14)
983 cols = strlen(HELP_PROMPT) + 14;
984
985 win = newwin(rows + 4, cols + 4, CALCPOSY(rows) - 2, CALCPOSX(cols));
986 set_menu_win(menu, win);
987 subw = derwin(win, rows, cols + 2, 2, 1);
988 set_menu_sub(menu, subw);
989 set_menu_fore(menu, A_REVERSE);
990 set_menu_grey(menu, A_NORMAL);
991 set_menu_mark(menu, NULL);
992 set_menu_pad(menu, '-');
993 set_menu_spacing(menu, 3, 0, 0);
994 menu_opts_off(menu, O_NONCYCLIC);
995 post_menu(menu);
996 panel = new_panel(win);
997 cbreak();
998 noecho();
999 nl();
1000 keypad(win, TRUE);
1001 set_menu_pattern(menu, mbuf);
1002 wbkgd(win, CP_MESSAGE_WINDOW);
1003 draw_window_title(win, (edit) ? TAG_EDIT_TITLE : TAG_VIEW_TITLE,
1004 cols + 4, CP_MESSAGE_TITLE, CP_MESSAGE_BORDER);
1005
1006 while (1) {
1007 int c;
1008 TAG **tmppgn = NULL;
1009 char *newtag = NULL;
1010
1011 if (set_current_item(menu, mitems[lastindex]) != E_OK) {
1012 lastindex = item_count(menu) - 1;
1013 continue;
1014 }
1015
1016 snprintf(buf, sizeof(buf), "%s %i %s %i %s", MENU_TAG_STR,
1017 item_index(current_item(menu)) + 1, N_OF_N_STR,
1018 item_count(menu), HELP_PROMPT);
1019 draw_prompt(win, rows + 2, cols + 4, buf, CP_MESSAGE_PROMPT);
1020 refresh_all();
1021 c = wgetch(win);
1022
1023 switch (c) {
1024 case CTRL('T'):
1025 add_custom_tags(&data);
1026 goto cleanup;
1027 break;
1028 case KEY_F(1):
1029 if (edit)
1030 help(TAG_EDIT_HELP, ANYKEY, pgn_edit_help);
1031 else
1032 help(TAG_VIEW_HELP, ANYKEY, pgn_info_help);
1033 break;
1034 case CTRL('R'):
1035 if (!edit)
1036 break;
1037
1038 selected = item_index(current_item(menu));
1039
1040 if (selected <= 6) {
1041 cmessage(NULL, ANYKEY, "%s", E_REMOVE_STR);
1042 goto cleanup;
1043 }
1044
1045 data_index = pgn_tag_total(data);
1046
1047 for (i = 0; i < data_index; i++) {
1048 if (i == selected)
1049 continue;
1050
1051 pgn_add_tag(&tmppgn, data[i]->name, data[i]->value);
1052 }
1053
1054 pgn_tag_free(data);
1055 data = NULL;
1056
1057 for (i = 0; tmppgn[i]; i++)
1058 pgn_add_tag(&data, tmppgn[i]->name, tmppgn[i]->value);
1059
1060 pgn_tag_free(tmppgn);
1061 goto cleanup;
1062 break;
1063 case CTRL('A'):
1064 if (!edit)
1065 break;
1066
1067 if ((newtag = get_input(TAG_NEW_TITLE, NULL, 1, 1, NULL,
1068 NULL, NULL, 0, FIELD_TYPE_PGN_TAG_NAME))
1069 == NULL)
1070 break;
1071
1072 newtag[0] = toupper(newtag[0]);
1073
1074 if (strlen(newtag) > MAX_VALUE_WIDTH - 6 -
1075 strlen(PRESS_ENTER)) {
1076 cmessage(ERROR, ANYKEY, "%s", E_TAG_NAMETOOLONG);
1077 break;
1078 }
1079
1080 for (i = 0; i < data_index; i++) {
1081 if (strcasecmp(data[i]->name, newtag) == 0) {
1082 selected = i;
1083 goto gotitem;
1084 }
1085 }
1086
1087 pgn_add_tag(&data, newtag, NULL);
1088 data_index = pgn_tag_total(data);
1089 selected = data_index - 1;
1090 goto gotitem;
1091 break;
1092 case KEY_HOME:
1093 menu_driver(menu, REQ_FIRST_ITEM);
1094 break;
1095 case KEY_END:
1096 menu_driver(menu, REQ_LAST_ITEM);
1097 break;
1098 case CTRL('F'):
1099 if (!edit)
1100 break;
1101
1102 pgn_add_tag(&data, "FEN", pgn_game_to_fen(g, b));
1103 data_index = pgn_tag_total(data);
1104 selected = data_index - 1;
1105 goto gotitem;
1106 break;
1107 case KEY_NPAGE:
1108 case CTRL('N'):
1109 if (menu_driver(menu, REQ_SCR_DPAGE) == E_REQUEST_DENIED)
1110 menu_driver(menu, REQ_LAST_ITEM);
1111 break;
1112 case KEY_PPAGE:
1113 case CTRL('P'):
1114 if (menu_driver(menu, REQ_SCR_UPAGE) == E_REQUEST_DENIED)
1115 menu_driver(menu, REQ_FIRST_ITEM);
1116 break;
1117 case KEY_UP:
1118 menu_driver(menu, REQ_UP_ITEM);
1119 break;
1120 case KEY_DOWN:
1121 menu_driver(menu, REQ_DOWN_ITEM);
1122 break;
1123 case '\n':
1124 selected = item_index(current_item(menu));
1125 goto gotitem;
1126 break;
1127 case KEY_ESCAPE:
1128 cleanup(win, subw, panel, menu, mitems, NULL);
1129 goto done;
1130 break;
1131 default:
1132 tmp = menu_pattern(menu);
1133
1134 if (tmp && tmp[strlen(tmp) - 1] != c) {
1135 menu_driver(menu, REQ_CLEAR_PATTERN);
1136 menu_driver(menu, c);
1137 }
1138 else {
1139 if (menu_driver(menu, REQ_NEXT_MATCH) == E_NO_MATCH)
1140 menu_driver(menu, c);
1141 }
1142
1143 break;
1144 }
1145
1146 lastindex = item_index(current_item(menu));
1147 }
1148
1149 gotitem:
1150 lastindex = selected;
1151 nlen = strlen(data[selected]->name) + 3;
1152 nlen += (edit) ? strlen(TAG_EDIT_TAG_TITLE) : strlen(TAG_VIEW_TAG_TITLE);
1153
1154 if (nlen > MAX_VALUE_WIDTH)
1155 snprintf(buf, sizeof(buf), "%s", data[selected]->name);
1156 else
1157 snprintf(buf, sizeof(buf), "%s \"%s\"",
1158 (edit) ? TAG_EDIT_TAG_TITLE : TAG_VIEW_TAG_TITLE,
1159 data[selected]->name);
1160
1161 if (!edit) {
1162 if (strcmp(item_description(mitems[selected]), UNKNOWN) == 0)
1163 goto cleanup;
1164
1165 cmessage(buf, ANYKEY, "%s", data[selected]->value);
1166 goto cleanup;
1167 }
1168
1169 if (strcmp(data[selected]->name, "Date") == 0) {
1170 tmp = get_input(buf, data[selected]->value, 0, 0, NULL, NULL, NULL,
1171 0, FIELD_TYPE_PGN_DATE);
1172
1173 if (tmp) {
1174 if (strptime(tmp, PGN_TIME_FORMAT, &tp) == NULL) {
1175 cmessage(ERROR, ANYKEY, "%s", E_TAG_DATE_FMT);
1176 goto cleanup;
1177 }
1178 }
1179 else
1180 goto cleanup;
1181 }
1182 else if (strcmp(data[selected]->name, "Site") == 0) {
1183 tmp = get_input(buf, data[selected]->value, 1, 1, CC_PROMPT,
1184 country_codes, NULL, CTRL('t'), -1);
1185
1186 if (!tmp)
1187 tmp = "?";
1188 }
1189 else if (strcmp(data[selected]->name, "Round") == 0) {
1190 tmp = get_input(buf, NULL, 1, 1, NULL, NULL, NULL, 0,
1191 FIELD_TYPE_PGN_ROUND);
1192
1193 if (!tmp) {
1194 if (gtotal > 1)
1195 tmp = "?";
1196 else
1197 tmp = "-";
1198 }
1199 }
1200 else if (strcmp(data[selected]->name, "Result") == 0) {
1201 tmp = get_input(buf, data[selected]->value, 1, 1, NULL, NULL, NULL,
1202 0, -1);
1203
1204 if (!tmp)
1205 tmp = "*";
1206 }
1207 else {
1208 if (item_description(mitems[selected]) &&
1209 strcmp(item_description(mitems[selected]), UNKNOWN) == 0)
1210 tmp = NULL;
1211 else
1212 tmp = data[selected]->value;
1213
1214 tmp = get_input(buf, tmp, 0, 0, NULL, NULL, NULL, 0, -1);
1215 }
1216
1217 len = (tmp) ? strlen(tmp) + 1 : 1;
1218 data[selected]->value = Realloc(data[selected]->value, len);
1219 strncpy(data[selected]->value, (tmp) ? tmp : "", len);
1220
1221 cleanup:
1222 cleanup(win, subw, panel, menu, mitems, NULL);
1223 }
1224
1225 done:
1226 if (!edit) {
1227 pgn_tag_free(data);
1228 return NULL;
1229 }
1230
1231 return data;
1232 }
1233
1234 /* If the saveindex argument is -1, all games will be saved. Otherwise it's a
1235 * game index number.
1236 */
1237 int save_pgn(const char *filename, int isfifo, int saveindex)
1238 {
1239 FILE *fp;
1240 char *mode = NULL;
1241 int c;
1242 char buf[FILENAME_MAX];
1243 struct stat st;
1244 int i;
1245 char *command = NULL;
1246 int saveindex_max = (saveindex == -1) ? gtotal : saveindex + 1;
1247
1248 if (filename[0] != '/' && config.savedirectory && !isfifo) {
1249 if (stat(config.savedirectory, &st) == -1) {
1250 if (errno == ENOENT) {
1251 if (mkdir(config.savedirectory, 0755) == -1) {
1252 cmessage(ERROR, ANYKEY, "%s: %s", config.savedirectory,
1253 strerror(errno));
1254 return 1;
1255 }
1256 }
1257 else {
1258 cmessage(ERROR, ANYKEY, "%s: %s", config.savedirectory,
1259 strerror(errno));
1260 return 1;
1261 }
1262 }
1263
1264 stat(config.savedirectory, &st);
1265
1266 if (!S_ISDIR(st.st_mode)) {
1267 cmessage(ERROR, ANYKEY, "%s: %s", config.savedirectory, E_NOTADIR);
1268 return 1;
1269 }
1270
1271 snprintf(buf, sizeof(buf), "%s/%s", config.savedirectory, filename);
1272 filename = buf;
1273 }
1274
1275 /* This is a hack to resume an existing game when more than one game is
1276 * available. Also resuming a saved game and a game from history.
1277 */
1278 // FIXME: may not need this when a FEN tag is supported (by the engine).
1279 if (isfifo)
1280 mode = "w";
1281 else {
1282 if (access(filename, W_OK) == 0) {
1283 c = cmessage(NULL, GAME_SAVE_OVERWRITE_PROMPT,
1284 "%s \"%s\"", E_FILEEXISTS, filename);
1285
1286 switch (c) {
1287 case 'a':
1288 if (pgn_is_compressed(filename)) {
1289 cmessage(NULL, ANYKEY, "%s", E_SAVE_COMPRESS);
1290 return 1;
1291 }
1292
1293 mode = "a";
1294 break;
1295 case 'o':
1296 mode = "w+";
1297 break;
1298 default:
1299 return 1;
1300 }
1301 }
1302 else
1303 mode = "a";
1304 }
1305
1306 if (command) {
1307 if ((fp = popen(command, "w")) == NULL) {
1308 cmessage(ERROR, ANYKEY, "%s: %s", filename, strerror(errno));
1309 return 1;
1310 }
1311 }
1312 else {
1313 if ((fp = fopen(filename, mode)) == NULL) {
1314 cmessage(ERROR, ANYKEY, "%s: %s", filename, strerror(errno));
1315 return 1;
1316 }
1317 }
1318
1319 if (isfifo)
1320 pgn_write(fp, game[saveindex]);
1321 else {
1322 for (i = (saveindex == -1) ? 0 : saveindex; i < saveindex_max; i++)
1323 pgn_write(fp, game[i]);
1324 }
1325
1326 if (command)
1327 pclose(fp);
1328 else
1329 fclose(fp);
1330
1331 if (!isfifo && saveindex == -1)
1332 strncpy(loadfile, filename, sizeof(loadfile));
1333
1334 return 0;
1335 }
1336
1337 char *random_agony(GAME g)
1338 {
1339 static int n;
1340 FILE *fp;
1341 char line[LINE_MAX];
1342
1343 if (n == -1 || !config.agony || !curses_initialized ||
1344 (g.mode == MODE_HISTORY && !config.historyagony))
1345 return NULL;
1346
1347 if (!agony) {
1348 if ((fp = fopen(config.agonyfile, "r")) == NULL) {
1349 n = -1;
1350 cmessage(ERROR, ANYKEY, "%s: %s", config.agonyfile, strerror(errno));
1351 return NULL;
1352 }
1353
1354 while (!feof(fp)) {
1355 if (fscanf(fp, " %[^\n] ", line) == 1) {
1356 agony = Realloc(agony, (n + 2) * sizeof(char *));
1357 agony[n++] = strdup(trim(line));
1358 }
1359 }
1360
1361 agony[n] = NULL;
1362 fclose(fp);
1363
1364 if (agony[0] == NULL || !n) {
1365 n = -1;
1366 return NULL;
1367 }
1368 }
1369
1370 return agony[random() % n];
1371 }
1372
1373 static int castling_state(GAME *g, BOARD b, int row, int col, int piece, int mod)
1374 {
1375 if (pgn_piece_to_int(piece) == ROOK && col == 7
1376 && row == 7 &&
1377 (TEST_FLAG(g->flags, GF_WK_CASTLE) || mod) &&
1378 pgn_piece_to_int(b[7][4].icon) == KING && isupper(piece)) {
1379 if (mod)
1380 TOGGLE_FLAG(g->flags, GF_WK_CASTLE);
1381 return 1;
1382 }
1383 else if (pgn_piece_to_int(piece) == ROOK && col == 0
1384 && row == 7 &&
1385 (TEST_FLAG(g->flags, GF_WQ_CASTLE) || mod) &&
1386 pgn_piece_to_int(b[7][4].icon) == KING && isupper(piece)) {
1387 if (mod)
1388 TOGGLE_FLAG(g->flags, GF_WQ_CASTLE);
1389 return 1;
1390 }
1391 else if (pgn_piece_to_int(piece) == ROOK && col == 7
1392 && row == 0 &&
1393 (TEST_FLAG(g->flags, GF_BK_CASTLE) || mod) &&
1394 pgn_piece_to_int(b[0][4].icon) == KING && islower(piece)) {
1395 if (mod)
1396 TOGGLE_FLAG(g->flags, GF_BK_CASTLE);
1397 return 1;
1398 }
1399 else if (pgn_piece_to_int(piece) == ROOK && col == 0
1400 && row == 0 &&
1401 (TEST_FLAG(g->flags, GF_BQ_CASTLE) || mod) &&
1402 pgn_piece_to_int(b[0][4].icon) == KING && islower(piece)) {
1403 if (mod)
1404 TOGGLE_FLAG(g->flags, GF_BQ_CASTLE);
1405 return 1;
1406 }
1407 else if (pgn_piece_to_int(piece) == KING && col == 4
1408 && row == 7 &&
1409 (mod || (pgn_piece_to_int(b[7][7].icon) == ROOK &&
1410 TEST_FLAG(g->flags, GF_WK_CASTLE))
1411 ||
1412 (pgn_piece_to_int(b[7][0].icon) == ROOK &&
1413 TEST_FLAG(g->flags, GF_WQ_CASTLE))) && isupper(piece)) {
1414 if (mod) {
1415 if (TEST_FLAG(g->flags, GF_WK_CASTLE) ||
1416 TEST_FLAG(g->flags, GF_WQ_CASTLE))
1417 CLEAR_FLAG(g->flags, GF_WK_CASTLE|GF_WQ_CASTLE);
1418 else
1419 SET_FLAG(g->flags, GF_WK_CASTLE|GF_WQ_CASTLE);
1420 }
1421 return 1;
1422 }
1423 else if (pgn_piece_to_int(piece) == KING && col == 4
1424 && row == 0 &&
1425 (mod || (pgn_piece_to_int(b[0][7].icon) == ROOK &&
1426 TEST_FLAG(g->flags, GF_BK_CASTLE))
1427 ||
1428 (pgn_piece_to_int(b[0][0].icon) == ROOK &&
1429 TEST_FLAG(g->flags, GF_BQ_CASTLE))) && islower(piece)) {
1430 if (mod) {
1431 if (TEST_FLAG(g->flags, GF_BK_CASTLE) ||
1432 TEST_FLAG(g->flags, GF_BQ_CASTLE))
1433 CLEAR_FLAG(g->flags, GF_BK_CASTLE|GF_BQ_CASTLE);
1434 else
1435 SET_FLAG(g->flags, GF_BK_CASTLE|GF_BQ_CASTLE);
1436 }
1437 return 1;
1438 }
1439
1440 return 0;
1441 }
1442
1443 static void draw_board(GAME *g, int details)
1444 {
1445 int row, col;
1446 int bcol = 0, brow = 0;
1447 int maxy = BOARD_HEIGHT, maxx = BOARD_WIDTH;
1448 int ncols = 0, offset = 1;
1449 unsigned coords_y = 8;
1450
1451 for (row = 0; row < maxy; row++) {
1452 bcol = 0;
1453
1454 for (col = 0; col < maxx; col++) {
1455 int attrwhich = -1;
1456 chtype attrs = 0;
1457 unsigned char piece;
1458
1459 if (row == 0 || row == maxy - 2) {
1460 if (col == 0)
1461 mvwaddch(boardw, row, col,
1462 LINE_GRAPHIC((row) ?
1463 ACS_LLCORNER | CP_BOARD_GRAPHICS :
1464 ACS_ULCORNER | CP_BOARD_GRAPHICS));
1465 else if (col == maxx - 2)
1466 mvwaddch(boardw, row, col,
1467 LINE_GRAPHIC((row) ?
1468 ACS_LRCORNER | CP_BOARD_GRAPHICS :
1469 ACS_URCORNER | CP_BOARD_GRAPHICS));
1470 else if (!(col % 4))
1471 mvwaddch(boardw, row, col,
1472 LINE_GRAPHIC((row) ?
1473 ACS_BTEE | CP_BOARD_GRAPHICS :
1474 ACS_TTEE | CP_BOARD_GRAPHICS));
1475 else {
1476 if (col != maxx - 1)
1477 mvwaddch(boardw, row, col,
1478 LINE_GRAPHIC(ACS_HLINE | CP_BOARD_GRAPHICS));
1479 }
1480
1481 continue;
1482 }
1483
1484 if ((row % 2) && col == maxx - 1 && coords_y) {
1485 wattron(boardw, CP_BOARD_COORDS);
1486 mvwprintw(boardw, row, col, "%d", coords_y--);
1487 wattroff(boardw, CP_BOARD_COORDS);
1488 continue;
1489 }
1490
1491 if ((col == 0 || col == maxx - 2) && row != maxy - 1) {
1492 if (!(row % 2))
1493 mvwaddch(boardw, row, col,
1494 LINE_GRAPHIC((col) ?
1495 ACS_RTEE | CP_BOARD_GRAPHICS :
1496 ACS_LTEE | CP_BOARD_GRAPHICS));
1497 else
1498 mvwaddch(boardw, row, col,
1499 LINE_GRAPHIC(ACS_VLINE | CP_BOARD_GRAPHICS));
1500
1501 continue;
1502 }
1503
1504 if ((row % 2) && !(col % 4) && row != maxy - 1) {
1505 mvwaddch(boardw, row, col,
1506 LINE_GRAPHIC(ACS_VLINE | CP_BOARD_GRAPHICS));
1507 continue;
1508 }
1509
1510 if (!(col % 4) && row != maxy - 1) {
1511 mvwaddch(boardw, row, col,
1512 LINE_GRAPHIC(ACS_PLUS | CP_BOARD_GRAPHICS));
1513 continue;
1514 }
1515
1516 if ((row % 2)) {
1517 if ((col % 4)) {
1518 if (ncols++ == 8) {
1519 offset++;
1520 ncols = 1;
1521 }
1522
1523 if (((ncols % 2) && !(offset % 2)) || (!(ncols % 2)
1524 && (offset % 2)))
1525 attrwhich = BLACK;
1526 else
1527 attrwhich = WHITE;
1528
1529 if (config.validmoves && g->b[brow][bcol].valid) {
1530 attrs = (attrwhich == WHITE) ? CP_BOARD_MOVES_WHITE :
1531 CP_BOARD_MOVES_BLACK;
1532 }
1533 else
1534 attrs = (attrwhich == WHITE) ? CP_BOARD_WHITE :
1535 CP_BOARD_BLACK;
1536
1537 if (row == ROWTOMATRIX(c_row) && col ==
1538 COLTOMATRIX(c_col)) {
1539 attrs = CP_BOARD_CURSOR;
1540 }
1541
1542 if (row == ROWTOMATRIX(sp.row) &&
1543 col == COLTOMATRIX(sp.col)) {
1544 attrs = CP_BOARD_SELECTED;
1545 }
1546
1547 if (row == maxy - 1)
1548 attrs = 0;
1549
1550 mvwaddch(boardw, row, col, ' ' | attrs);
1551
1552 if (row == maxy - 1)
1553 waddch(boardw, x_grid_chars[bcol] | CP_BOARD_COORDS);
1554 else {
1555 if (details && g->b[row / 2][bcol].enpassant)
1556 piece = 'x';
1557 else
1558 piece = g->b[row / 2][bcol].icon;
1559
1560 if (details && castling_state(g, g->b, brow, bcol,
1561 piece, 0))
1562 attrs |= A_REVERSE;
1563
1564 if (g->side == WHITE && isupper(piece))
1565 attrs |= A_BOLD;
1566 else if (g->side == BLACK && islower(piece))
1567 attrs |= A_BOLD;
1568
1569 waddch(boardw, (pgn_piece_to_int(piece) != OPEN_SQUARE) ? piece | attrs : ' ' | attrs);
1570
1571 CLEAR_FLAG(attrs, A_BOLD);
1572 CLEAR_FLAG(attrs, A_REVERSE);
1573 }
1574
1575 waddch(boardw, ' ' | attrs);
1576 col += 2;
1577 bcol++;
1578 }
1579 }
1580 else {
1581 if (col != maxx - 1)
1582 mvwaddch(boardw, row, col,
1583 LINE_GRAPHIC(ACS_HLINE | CP_BOARD_GRAPHICS));
1584 }
1585 }
1586
1587 brow = row / 2;
1588 }
1589 }
1590
1591 void invalid_move(int n, const char *m)
1592 {
1593 if (curses_initialized)
1594 cmessage(ERROR, ANYKEY, "%s \"%s\" (round #%i)", E_INVALID_MOVE, m, n);
1595 else
1596 warnx("%s: %s \"%s\" (round #%i)", loadfile, E_INVALID_MOVE, m, n);
1597 }
1598
1599 /* Convert the selected piece to SAN format and validate it. */
1600 static char *board_to_san(GAME *g, BOARD b)
1601 {
1602 static char str[MAX_SAN_MOVE_LEN + 1], *p;
1603 int piece;
1604 int promo;
1605 BOARD oldboard;
1606
1607 snprintf(str, sizeof(str), "%c%i%c%i", x_grid_chars[sp.col - 1],
1608 sp.row, x_grid_chars[sp.destcol - 1], sp.destrow);
1609
1610 p = str;
1611 piece = pgn_piece_to_int(b[ROWTOBOARD(sp.row)][COLTOBOARD(sp.col)].icon);
1612
1613 if (piece == PAWN && ((sp.destrow == 8 && g->turn == WHITE) ||
1614 (sp.destrow == 1 && g->turn == BLACK))) {
1615 promo = cmessage(PROMOTION_TITLE, PROMOTION_PROMPT, PROMOTION_TEXT);
1616
1617 if (pgn_piece_to_int(promo) == -1)
1618 return NULL;
1619
1620 p = str + strlen(str);
1621 *p++ = toupper(promo);
1622 *p = '\0';
1623 }
1624
1625 memcpy(oldboard, b, sizeof(BOARD));
1626
1627 if ((p = pgn_a2a4tosan(g, b, str)) == NULL) {
1628 cmessage(p, ANYKEY, "%s", E_A2A4_PARSE);
1629 memcpy(b, oldboard, sizeof(BOARD));
1630 return NULL;
1631 }
1632
1633 if (pgn_validate_move(g, b, p)) {
1634 invalid_move(gindex + 1, p);
1635 memcpy(b, oldboard, sizeof(BOARD));
1636 return NULL;
1637 }
1638
1639 return p;
1640 }
1641
1642 static int move_to_engine(GAME *g, BOARD b)
1643 {
1644 char *p;
1645
1646 if ((p = board_to_san(g, b)) == NULL)
1647 return 0;
1648
1649 sp.row = sp.col = sp.icon = 0;
1650
1651 if (noengine) {
1652 history_add(g, p);
1653 pgn_switch_turn(g);
1654 SET_FLAG(g->flags, GF_MODIFIED);
1655 update_all(*g);
1656 return 1;
1657 }
1658
1659 send_to_engine(g, "%s\n", p);
1660 return 1;
1661 }
1662
1663 static void update_clock(int n, int *h, int *m, int *s)
1664 {
1665 *h = n / 3600;
1666 *m = (n % 3600) / 60;
1667 *s = (n % 3600) % 60;
1668
1669 return;
1670 }
1671
1672 void update_status_window(GAME g)
1673 {
1674 int i = 0;
1675 char *buf;
1676 char tmp[15], *engine, *mode;
1677 int w;
1678 int h, m, s;
1679 char *p;
1680 int maxy, maxx;
1681 int len;
1682 struct user_data_s *d = g.data;
1683
1684 getmaxyx(statusw, maxy, maxx);
1685 w = maxx - 2 - 8;
1686 len = maxx - 2;
1687 buf = Malloc(len);
1688
1689 *tmp = '\0';
1690 p = tmp;
1691
1692 if (TEST_FLAG(g.flags, GF_DELETE)) {
1693 *p++ = '(';
1694 *p++ = 'x';
1695 i++;
1696 }
1697
1698 if (TEST_FLAG(g.flags, GF_PERROR)) {
1699 if (!i)
1700 *p++ = '(';
1701 else
1702 *p++ = '/';
1703
1704 *p++ = '!';
1705 i++;
1706 }
1707
1708 if (TEST_FLAG(g.flags, GF_MODIFIED)) {
1709 if (!i)
1710 *p++ = '(';
1711 else
1712 *p++ = '/';
1713
1714 *p++ = '*';
1715 i++;
1716 }
1717
1718 if (*tmp != '\0')
1719 *p++ = ')';
1720
1721 *p = '\0';
1722
1723 mvwprintw(statusw, 2, 1, "%*s %-*s", 7, STATUS_FILE_STR, w,
1724 (loadfile[0]) ? str_etc(loadfile, w, 1) : UNAVAILABLE);
1725 snprintf(buf, len, "%i %s %i %s", gindex + 1, N_OF_N_STR, gtotal,
1726 (*tmp) ? tmp : "");
1727 mvwprintw(statusw, 3, 1, "%*s %-*s", 7, STATUS_GAME_STR, w, buf);
1728
1729 switch (g.mode) {
1730 case MODE_HISTORY:
1731 mode = MODE_HISTORY_STR;
1732 break;
1733 case MODE_EDIT:
1734 mode = MODE_EDIT_STR;
1735 break;
1736 case MODE_PLAY:
1737 mode = MODE_PLAY_STR;
1738 break;
1739 default:
1740 mode = UNKNOWN;
1741 break;
1742 }
1743
1744 snprintf(buf, len - 1, "%*s %s%s", 7, STATUS_MODE_STR, mode,
1745 (d && TEST_FLAG(d->flags, CF_ENGINE_LOOP)) ? " (loop)" : "");
1746 mvwprintw(statusw, 4, 1, "%-*s", w, buf);
1747
1748 if (d) {
1749 switch (d->status) {
1750 case ENGINE_THINKING:
1751 engine = ENGINE_THINKING_STR;
1752 break;
1753 case ENGINE_READY:
1754 engine = ENGINE_READY_STR;
1755 break;
1756 case ENGINE_INITIALIZING:
1757 engine = ENGINE_INITIALIZING_STR;
1758 break;
1759 case ENGINE_OFFLINE:
1760 engine = ENGINE_OFFLINE_STR;
1761 break;
1762 default:
1763 engine = UNKNOWN;
1764 break;
1765 }
1766 }
1767 else
1768 engine = ENGINE_OFFLINE_STR;
1769
1770 mvwprintw(statusw, 5, 1, "%*s %-*s", 7, STATUS_ENGINE_STR, w, " ");
1771 wattron(statusw, CP_STATUS_ENGINE);
1772 mvwaddstr(statusw, 5, 9, engine);
1773 wattroff(statusw, CP_STATUS_ENGINE);
1774
1775 mvwprintw(statusw, 6, 1, "%*s %-*s", 7, STATUS_TURN_STR, w,
1776 (g.turn == WHITE) ? WHITE_STR : BLACK_STR);
1777
1778 strncpy(tmp, WHITE_STR, sizeof(tmp));
1779 tmp[0] = toupper(tmp[0]);
1780 update_clock(g.moveclock, &h, &m, &s);
1781 snprintf(buf, len, "%.2i:%.2i:%.2i", h, m, s);
1782 mvwprintw(statusw, 7, 1, "%*s: %-*s", 6, tmp, w, buf);
1783
1784 strncpy(tmp, BLACK_STR, sizeof(tmp));
1785 tmp[0] = toupper(tmp[0]);
1786 update_clock(g.moveclock, &h, &m, &s);
1787 snprintf(buf, len, "%.2i:%.2i:%.2i", h, m, s);
1788 mvwprintw(statusw, 8, 1, "%*s: %-*s", 6, tmp, w, buf);
1789 free(buf);
1790
1791 for (i = 1; i < maxx - 4; i++)
1792 mvwprintw(statusw, maxy - 2, i, " ");
1793
1794 if (!status.notify)
1795 status.notify = strdup(GAME_HELP_PROMPT);
1796
1797 wattron(statusw, CP_STATUS_NOTIFY);
1798 mvwprintw(statusw, maxy - 2, CENTERX(maxx, status.notify), "%s",
1799 status.notify);
1800 wattroff(statusw, CP_STATUS_NOTIFY);
1801 }
1802
1803 void update_history_window(GAME g)
1804 {
1805 char buf[HISTORY_WIDTH - 1];
1806 HISTORY *h = NULL;
1807 int n, total;
1808 int t = history_total(g.hp);
1809
1810 n = (g.hindex + 1) / 2;
1811
1812 if (t % 2)
1813 total = (t + 1) / 2;
1814 else
1815 total = t / 2;
1816
1817 if (t)
1818 snprintf(buf, sizeof(buf), "%u %s %u%s", n, N_OF_N_STR, total,
1819 (movestep == 1) ? HISTORY_PLY_STEP : "");
1820 else
1821 strncpy(buf, UNAVAILABLE, sizeof(buf));
1822
1823 mvwprintw(historyw, 2, 1, "%*s %-*s", 10, HISTORY_MOVE_STR,
1824 HISTORY_WIDTH - 13, buf);
1825
1826 h = history_by_n(g.hp, g.hindex);
1827 snprintf(buf, sizeof(buf), "%s", (h && h->move) ? h->move : UNAVAILABLE);
1828 n = 0;
1829
1830 if (h && ((h->comment) || h->nag[0])) {
1831 strncat(buf, " (v", sizeof(buf));
1832 n++;
1833 }
1834
1835 if (h && h->rav) {
1836 strncat(buf, (n) ? ",+" : " (+", sizeof(buf));
1837 n++;
1838 }
1839
1840 if (g.ravlevel) {
1841 strncat(buf, (n) ? ",-" : " (-", sizeof(buf));
1842 n++;
1843 }
1844
1845 if (n)
1846 strncat(buf, ")", sizeof(buf));
1847
1848 mvwprintw(historyw, 3, 1, "%s %-*s", HISTORY_MOVE_NEXT_STR,
1849 HISTORY_WIDTH - 13, buf);
1850
1851 h = history_by_n(g.hp, game[gindex].hindex - 1);
1852 snprintf(buf, sizeof(buf), "%s", (h && h->move) ? h->move : UNAVAILABLE);
1853 n = 0;
1854
1855 if (h && ((h->comment) || h->nag[0])) {
1856 strncat(buf, " (V", sizeof(buf));
1857 n++;
1858 }
1859
1860 if (h && h->rav) {
1861 strncat(buf, (n) ? ",+" : " (+", sizeof(buf));
1862 n++;
1863 }
1864
1865 if (g.ravlevel) {
1866 strncat(buf, (n) ? ",-" : " (-", sizeof(buf));
1867 n++;
1868 }
1869
1870 if (n)
1871 strncat(buf, ")", sizeof(buf));
1872
1873 mvwprintw(historyw, 4, 1, "%s %-*s", HISTORY_MOVE_PREV_STR,
1874 HISTORY_WIDTH - 13, buf);
1875 }
1876
1877 void update_tag_window(TAG **t)
1878 {
1879 int i;
1880 int w = TAG_WIDTH - 10;
1881
1882 for (i = 0; i < 7; i++)
1883 mvwprintw(tagw, (i + 2), 1, "%*s: %-*s", 6, t[i]->name, w, t[i]->value);
1884 }
1885
1886 void draw_prompt(WINDOW *win, int y, int width, const char *str, chtype attr)
1887 {
1888 int i;
1889
1890 wattron(win, attr);
1891
1892 for (i = 1; i < width - 1; i++)
1893 mvwaddch(win, y, i, ' ');
1894
1895 mvwprintw(win, y, CENTERX(width, str), "%s", str);
1896 wattroff(win, attr);
1897 }
1898
1899 void draw_window_title(WINDOW *win, const char *title, int width, chtype attr,
1900 chtype battr)
1901 {
1902 int i;
1903
1904 if (title) {
1905 wattron(win, attr);
1906
1907 for (i = 1; i < width - 1; i++)
1908 mvwaddch(win, 1, i, ' ');
1909
1910 mvwprintw(win, 1, CENTERX(width, title), "%s", title);
1911 wattroff(win, attr);
1912 }
1913
1914 wattron(win, battr);
1915 box(win, ACS_VLINE, ACS_HLINE);
1916 wattroff(win, battr);
1917 }
1918
1919 void refresh_all()
1920 {
1921 update_panels();
1922 doupdate();
1923 }
1924
1925 void update_all(GAME g)
1926 {
1927 update_status_window(g);
1928 update_history_window(g);
1929 update_tag_window(g.tag);
1930 }
1931
1932 static void game_next_prev(GAME g, int n, int count)
1933 {
1934 if (gtotal < 2)
1935 return;
1936
1937 if (n == 1) {
1938 if (gindex + count > gtotal - 1) {
1939 if (count != 1)
1940 gindex = gtotal - 1;
1941 else
1942 gindex = 0;
1943 }
1944 else
1945 gindex += count;
1946 }
1947 else {
1948 if (gindex - count < 0) {
1949 if (count != 1)
1950 gindex = 0;
1951 else
1952 gindex = gtotal - 1;
1953 }
1954 else
1955 gindex -= count;
1956 }
1957 }
1958
1959 static void delete_game(int which)
1960 {
1961 GAME *g = NULL;
1962 int gi = 0;
1963 int i;
1964
1965 for (i = 0; i < gtotal; i++) {
1966 if (i == which || TEST_FLAG(game[i].flags, GF_DELETE)) {
1967 pgn_free(game[i]);
1968 continue;
1969 }
1970
1971 g = Realloc(g, (gi + 1) * sizeof(GAME));
1972 memcpy(&g[gi], &game[i], sizeof(GAME));
1973 g[gi].tag = game[i].tag;
1974 g[gi].history = game[i].history;
1975 g[gi].hp = game[i].hp;
1976 gi++;
1977 }
1978
1979 game = g;
1980 gtotal = gi;
1981
1982 if (which != -1) {
1983 if (which + 1 >= gtotal)
1984 gindex = gtotal - 1;
1985 else
1986 gindex = which;
1987 }
1988 else
1989 gindex = gtotal - 1;
1990
1991 game[gindex].hp = game[gindex].history;
1992 }
1993
1994 static int find_move_exp(GAME g, const char *str, int init, int which,
1995 int count)
1996 {
1997 int i;
1998 int ret;
1999 static regex_t r;
2000 static int firstrun = 1;
2001 char errbuf[255];
2002 int incr;
2003 int found;
2004
2005 if (init) {
2006 if (!firstrun)
2007 regfree(&r);
2008
2009 if ((ret = regcomp(&r, str, REG_EXTENDED|REG_NOSUB)) != 0) {
2010 regerror(ret, &r, errbuf, sizeof(errbuf));
2011 cmessage(E_REGCOMP_TITLE, ANYKEY, "%s", errbuf);
2012 return -1;
2013 }
2014
2015 firstrun = 1;
2016 }
2017
2018 incr = (which == 0) ? -1 : 1;
2019
2020 for (i = g.hindex + incr - 1, found = 0; ; i += incr) {
2021 if (i == g.hindex - 1)
2022 break;
2023
2024 if (i >= history_total(g.hp))
2025 i = 0;
2026 else if (i < 0)
2027 i = history_total(g.hp) - 1;
2028
2029 // FIXME RAV
2030 ret = regexec(&r, g.hp[i]->move, 0, 0, 0);
2031
2032 if (ret == 0) {
2033 if (count == ++found) {
2034 return i + 1;
2035 }
2036 }
2037 else {
2038 if (ret != REG_NOMATCH) {
2039 regerror(ret, &r, errbuf, sizeof(errbuf));
2040 cmessage(E_REGEXEC_TITLE, ANYKEY, "%s", errbuf);
2041 return -1;
2042 }
2043 }
2044 }
2045
2046 return -1;
2047 }
2048
2049 static int toggle_delete_flag(int n)
2050 {
2051 int i, x;
2052
2053 TOGGLE_FLAG(game[n].flags, GF_DELETE);
2054
2055 for (i = x = 0; i < gtotal; i++) {
2056 if (TEST_FLAG(game[i].flags, GF_DELETE))
2057 x++;
2058 }
2059
2060 if (x == gtotal) {
2061 cmessage(NULL, ANYKEY, "%s", E_DELETE_GAME);
2062 CLEAR_FLAG(game[n].flags, GF_DELETE);
2063 return 1;
2064 }
2065
2066 return 0;
2067 }
2068
2069 static void edit_save_tags(GAME *g)
2070 {
2071 TAG **t;
2072
2073 if ((t = edit_tags(*g, g->b, 1)) == NULL)
2074 return;
2075
2076 pgn_tag_free(g->tag);
2077 g->tag = t;
2078 SET_FLAG(g->flags, GF_MODIFIED);
2079 pgn_sort_tags(g->tag);
2080 }
2081
2082 static int find_game_exp(char *str, int which, int count)
2083 {
2084 char *nstr = NULL, *exp = NULL;
2085 regex_t nexp, vexp;
2086 int ret = -1;
2087 int g = 0;
2088 char buf[255], *tmp;
2089 char errbuf[255];
2090 int found = 0;
2091 int incr = (which == 0) ? -(1) : 1;
2092
2093 strncpy(buf, str, sizeof(buf));
2094 tmp = buf;
2095
2096 if (strstr(tmp, ":") != NULL) {
2097 nstr = strsep(&tmp, ":");
2098
2099 if ((ret = regcomp(&nexp, nstr,
2100 REG_ICASE|REG_EXTENDED|REG_NOSUB)) != 0) {
2101 regerror(ret, &nexp, errbuf, sizeof(errbuf));
2102 cmessage(E_REGCOMP_TITLE, ANYKEY, "%s", errbuf);
2103 ret = g = -1;
2104 goto cleanup;
2105 }
2106 }
2107
2108 exp = tmp;
2109
2110 if (exp == NULL)
2111 goto cleanup;
2112
2113 if ((ret = regcomp(&vexp, exp, REG_EXTENDED|REG_NOSUB)) != 0) {
2114 regerror(ret, &vexp, errbuf, sizeof(errbuf));
2115 cmessage(E_REGCOMP_TITLE, ANYKEY, "%s", errbuf);
2116 ret = -1;
2117 goto cleanup;
2118 }
2119
2120 ret = -1;
2121
2122 for (g = gindex + incr, found = 0; ; g += incr) {
2123 int t;
2124
2125 if (g == gindex)
2126 break;
2127
2128 if (g == gtotal)
2129 g = 0;
2130 else if (g < 0)
2131 g = gtotal - 1;
2132
2133 for (t = 0; game[g].tag[t]; t++) {
2134 if (nstr) {
2135 if (regexec(&nexp, game[g].tag[t]->name, 0, 0, 0) == 0) {
2136 if (regexec(&vexp, game[g].tag[t]->value, 0, 0, 0) == 0) {
2137 if (count == ++found) {
2138 ret = g;
2139 goto cleanup;
2140 }
2141 }
2142 }
2143 }
2144 else {
2145 if (regexec(&vexp, game[g].tag[t]->value, 0, 0, 0) == 0) {
2146 if (count == ++found) {
2147 ret = g;
2148 goto cleanup;
2149 }
2150 }
2151 }
2152 }
2153
2154 ret = -1;
2155 }
2156
2157 cleanup:
2158 if (nstr)
2159 regfree(&nexp);
2160
2161 if (g != -1)
2162 regfree(&vexp);
2163
2164 return ret;
2165 }
2166
2167 /*
2168 * Updates the notification line in the status window then refreshes the
2169 * status window.
2170 */
2171 void update_status_notify(GAME g, char *fmt, ...)
2172 {
2173 va_list ap;
2174 #ifdef HAVE_VASPRINTF
2175 char *line;
2176 #else
2177 char line[COLS];
2178 #endif
2179
2180 if (!fmt) {
2181 if (status.notify) {
2182 free(status.notify);
2183 status.notify = NULL;
2184
2185 if (curses_initialized)
2186 update_status_window(g);
2187 }
2188
2189 return;
2190 }
2191
2192 va_start(ap, fmt);
2193 #ifdef HAVE_VASPRINTF
2194 vasprintf(&line, fmt, ap);
2195 #else
2196 vsnprintf(line, sizeof(line), fmt, ap);
2197 #endif
2198 va_end(ap);
2199
2200 if (status.notify)
2201 free(status.notify);
2202
2203 status.notify = strdup(line);
2204
2205 #ifdef HAVE_VASPRINTF
2206 free(line);
2207 #endif
2208 if (curses_initialized)
2209 update_status_window(g);
2210 }
2211
2212 static void switch_side(GAME *g)
2213 {
2214 g->side = (g->side == WHITE) ? BLACK : WHITE;
2215 }
2216
2217 int rav_next_prev(GAME *g, BOARD b, int n)
2218 {
2219 // Next RAV.
2220 if (n) {
2221 if (g->hp[g->hindex]->rav == NULL)
2222 return 1;
2223
2224 g->rav = Realloc(g->rav, (g->ravlevel + 1) * sizeof(RAV));
2225 g->rav[g->ravlevel].hp = g->hp;
2226 g->rav[g->ravlevel].flags = g->flags;
2227 g->rav[g->ravlevel].fen = strdup(pgn_game_to_fen(*g, b));
2228 g->rav[g->ravlevel].hindex = g->hindex;
2229 g->hp = g->hp[g->hindex]->rav;
2230 g->hindex = 0;
2231 g->ravlevel++;
2232 return 0;
2233 }
2234
2235 if (g->ravlevel - 1 < 0)
2236 return 1;
2237
2238 // Previous RAV.
2239 g->ravlevel--;
2240 pgn_init_fen_board(g, b, g->rav[g->ravlevel].fen);
2241 free(g->rav[g->ravlevel].fen);
2242 g->hp = g->rav[g->ravlevel].hp;
2243 g->flags = g->rav[g->ravlevel].flags;
2244 g->hindex = g->rav[g->ravlevel].hindex;
2245 return 0;
2246 }
2247
2248 static void draw_window_decor()
2249 {
2250 move_panel(historyp, LINES - HISTORY_HEIGHT, COLS - HISTORY_WIDTH);
2251 move_panel(boardp, 0, COLS - BOARD_WIDTH);
2252 wbkgd(boardw, CP_BOARD_WINDOW);
2253 wbkgd(statusw, CP_STATUS_WINDOW);
2254 draw_window_title(statusw, STATUS_WINDOW_TITLE, STATUS_WIDTH,
2255 CP_STATUS_TITLE, CP_STATUS_BORDER);
2256 wbkgd(tagw, CP_TAG_WINDOW);
2257 draw_window_title(tagw, TAG_WINDOW_TITLE, TAG_WIDTH, CP_TAG_TITLE,
2258 CP_TAG_BORDER);
2259 wbkgd(historyw, CP_HISTORY_WINDOW);
2260 draw_window_title(historyw, HISTORY_WINDOW_TITLE, HISTORY_WIDTH,
2261 CP_HISTORY_TITLE, CP_HISTORY_BORDER);
2262 }
2263
2264 static void do_window_resize()
2265 {
2266 if (LINES < 24 || COLS < 80)
2267 return;
2268
2269 resizeterm(LINES, COLS);
2270 wresize(historyw, HISTORY_HEIGHT, HISTORY_WIDTH);
2271 wresize(statusw, STATUS_HEIGHT, STATUS_WIDTH);
2272 wresize(tagw, TAG_HEIGHT, TAG_WIDTH);
2273 wmove(historyw, 0, 0);
2274 wclrtobot(historyw);
2275 wmove(tagw, 0, 0);
2276 wclrtobot(tagw);
2277 wmove(statusw, 0, 0);
2278 wclrtobot(statusw);
2279 draw_window_decor();
2280 update_all(game[gindex]);
2281 }
2282
2283 static void historymode_keys(int);
2284 static void playmode_keys(int c)
2285 {
2286 // More keys in MODE_EDIT share keys with MODE_PLAY than don't.
2287 int editmode = (game[gindex].mode == MODE_EDIT) ? 1 : 0;
2288 chtype p;
2289 int w, x, y, z;
2290 char *tmp;
2291 struct user_data_s *d = game[gindex].data;
2292
2293 switch (c) {
2294 case 'o':
2295 if (!d)
2296 break;
2297
2298 TOGGLE_FLAG(d->flags, CF_ENGINE_LOOP);
2299 update_all(game[gindex]);
2300 break;
2301 case '|':
2302 if (!d)
2303 break;
2304
2305 if (d->status == ENGINE_OFFLINE)
2306 break;
2307
2308 x = d->status;
2309
2310 if ((tmp = get_input_str_clear(ENGINE_CMD_TITLE, NULL)) != NULL)
2311 send_to_engine(&game[gindex], "%s\n", tmp);
2312 d->status = x;
2313 break;
2314 case '\015':
2315 case '\n':
2316 pushkey = keycount = 0;
2317 update_status_notify(game[gindex], NULL);
2318
2319 if (!noengine && (!d || d->status == ENGINE_THINKING)) {
2320 beep();
2321 break;
2322 }
2323
2324 if (!sp.icon)
2325 break;
2326
2327 sp.destrow = c_row;
2328 sp.destcol = c_col;
2329
2330 if (editmode) {
2331 p = game[gindex].b[ROWTOBOARD(sp.row)][COLTOBOARD(sp.col)].icon;
2332 game[gindex].b[ROWTOBOARD(sp.destrow)][COLTOBOARD(sp.destcol)].icon = p;
2333 game[gindex].b[ROWTOBOARD(sp.row)][COLTOBOARD(sp.col)].icon = pgn_int_to_piece(game[gindex].turn, OPEN_SQUARE);
2334 sp.icon = sp.row = sp.col = 0;
2335 break;
2336 }
2337
2338 if (move_to_engine(&game[gindex], game[gindex].b)) {
2339 if (config.validmoves)
2340 board_reset_valid_moves(game[gindex].b);
2341
2342 if (TEST_FLAG(game[gindex].flags, GF_GAMEOVER)) {
2343 CLEAR_FLAG(game[gindex].flags, GF_GAMEOVER);
2344 SET_FLAG(game[gindex].flags, GF_MODIFIED);
2345 }
2346 }
2347
2348 break;
2349 case ' ':
2350 if (!noengine && (!d || d->status == ENGINE_OFFLINE) && !editmode) {
2351 if (start_chess_engine(&game[gindex]) < 0) {
2352 sp.icon = 0;
2353 break;
2354 }
2355 }
2356
2357 if (!editmode)
2358 wtimeout(boardw, 70);
2359
2360 if (sp.icon || (!editmode && d && d->status == ENGINE_THINKING)) {
2361 beep();
2362 break;
2363 }
2364
2365 sp.icon = mvwinch(boardw, ROWTOMATRIX(c_row),
2366 COLTOMATRIX(c_col)+1) & A_CHARTEXT;
2367
2368 if (sp.icon == ' ') {
2369 sp.icon = 0;
2370 break;
2371 }
2372
2373 if (!editmode && ((islower(sp.icon) && game[gindex].turn != BLACK)
2374 || (isupper(sp.icon) && game[gindex].turn != WHITE))) {
2375 message(NULL, ANYKEY, "%s", E_SELECT_TURN);
2376 sp.icon = 0;
2377 break;
2378 }
2379
2380 sp.row = c_row;
2381 sp.col = c_col;
2382
2383 if (!editmode && config.validmoves)
2384 board_get_valid_moves(&game[gindex], game[gindex].b,
2385 pgn_piece_to_int(sp.icon), sp.row, sp.col, &w, &x, &y, &z);
2386
2387 paused = 0;
2388 break;
2389 case 'w':
2390 send_to_engine(&game[gindex], "\nswitch\n");
2391 switch_side(&game[gindex]);
2392 update_status_window(game[gindex]);
2393 break;
2394 case 'u':
2395 /* FIXME dies reading FIFO sometimes. */
2396 if (!history_total(game[gindex].hp))
2397 break;
2398
2399 history_previous(&game[gindex], game[gindex].b, (keycount) ? keycount * 2 :
2400 2);
2401
2402 #if 0
2403 if (status.engine == CRAFTY)
2404 SEND_TO_ENGINE("read %s\n", config.fifo);
2405 else
2406 SEND_TO_ENGINE("\npgnload %s\n", config.fifo);
2407 #endif
2408
2409 update_history_window(game[gindex]);
2410 break;
2411 case 'a':
2412 historymode_keys(c);
2413 break;
2414 case 'd':
2415 board_details = (board_details) ? 0 : 1;
2416 break;
2417 case 'p':
2418 paused = (paused) ? 0 : 1;
2419 break;
2420 case 'g':
2421 if (!d || d->status == ENGINE_OFFLINE)
2422 start_chess_engine(&game[gindex]);
2423
2424 send_to_engine(&game[gindex], "go\n");
2425 break;
2426 default:
2427 break;
2428 }
2429 }
2430
2431 static void editmode_keys(int c)
2432 {
2433 switch (c) {
2434 case '\015':
2435 case '\n':
2436 case ' ':
2437 playmode_keys(c);
2438 break;
2439 case 'd':
2440 if (sp.icon)
2441 game[gindex].b[ROWTOBOARD(sp.row)][COLTOBOARD(sp.col)].icon = pgn_int_to_piece(game[gindex].turn, OPEN_SQUARE);
2442 else
2443 game[gindex].b[ROWTOBOARD(c_row)][COLTOBOARD(c_col)].icon = pgn_int_to_piece(game[gindex].turn, OPEN_SQUARE);
2444
2445 sp.icon = sp.row = sp.col = 0;
2446 break;
2447 case 'w':
2448 pgn_switch_turn(&game[gindex]);
2449 switch_side(&game[gindex]);
2450 update_all(game[gindex]);
2451 break;
2452 case 'c':
2453 castling_state(&game[gindex], game[gindex].b, ROWTOBOARD(c_row),
2454 COLTOBOARD(c_col),
2455 game[gindex].b[ROWTOBOARD(c_row)][COLTOBOARD(c_col)].icon, 1);
2456 break;
2457 case 'i':
2458 c = message(GAME_EDIT_TITLE, GAME_EDIT_PROMPT, "%s",
2459 GAME_EDIT_TEXT);
2460
2461 if (pgn_piece_to_int(c) == -1)
2462 break;
2463
2464 game[gindex].b[ROWTOBOARD(c_row)][COLTOBOARD(c_col)].icon = c;
2465 break;
2466 case 'p':
2467 if (c_row == 6 || c_row == 3) {
2468 pgn_reset_enpassant(game[gindex].b);
2469 game[gindex].b[ROWTOBOARD(c_row)][COLTOBOARD(c_col)].enpassant = 1;
2470 }
2471 break;
2472 default:
2473 break;
2474 }
2475 }
2476
2477 static void historymode_keys(int c)
2478 {
2479 int n, len;
2480 char *tmp, *buf;
2481 static char moveexp[255] = {0};
2482
2483 switch (c) {
2484 case ' ':
2485 movestep = (movestep == 1) ? 2 : 1;
2486 update_history_window(game[gindex]);
2487 break;
2488 case KEY_UP:
2489 history_next(&game[gindex], game[gindex].b, (keycount > 0) ?
2490 config.jumpcount * keycount * movestep :
2491 config.jumpcount * movestep);
2492 update_cursor(game[gindex], game[gindex].hindex);
2493 update_all(game[gindex]);
2494 break;
2495 case KEY_DOWN:
2496 history_previous(&game[gindex], game[gindex].b, (keycount) ?
2497 config.jumpcount * keycount * movestep :
2498 config.jumpcount * movestep);
2499 update_cursor(game[gindex], game[gindex].hindex);
2500 update_all(game[gindex]);
2501 break;
2502 case KEY_LEFT:
2503 history_previous(&game[gindex], game[gindex].b, (keycount) ?
2504 keycount * movestep : movestep);
2505 update_cursor(game[gindex], game[gindex].hindex);
2506 update_all(game[gindex]);
2507 break;
2508 case KEY_RIGHT:
2509 history_next(&game[gindex], game[gindex].b, (keycount) ?
2510 keycount * movestep : movestep);
2511 update_cursor(game[gindex], game[gindex].hindex);
2512 update_all(game[gindex]);
2513 break;
2514 case 'a':
2515 n = game[gindex].hindex;
2516
2517 if (n && game[gindex].hp[n - 1]->move)
2518 n--;
2519 else
2520 break;
2521
2522 buf = Malloc(COLS);
2523 snprintf(buf, COLS - 1, "%s \"%s\"", ANNOTATION_EDIT_TITLE,
2524 game[gindex].hp[n]->move);
2525
2526 tmp = get_input(buf, game[gindex].hp[n]->comment, 0, 0, NAG_PROMPT,
2527 history_edit_nag, (void *)game[gindex].hp[n], CTRL('T'),
2528 -1);
2529 free(buf);
2530
2531 if (!tmp && (!game[gindex].hp[n]->comment ||
2532 !*game[gindex].hp[n]->comment))
2533 break;
2534 else if (tmp && game[gindex].hp[n]->comment) {
2535 if (strcmp(tmp, game[gindex].hp[n]->comment) == 0)
2536 break;
2537 }
2538
2539 len = (tmp) ? strlen(tmp) + 1 : 1;
2540 game[gindex].hp[n]->comment = Realloc(game[gindex].hp[n]->comment,
2541 len);
2542 strncpy(game[gindex].hp[n]->comment, (tmp) ? tmp : "", len);
2543 SET_FLAG(game[gindex].flags, GF_MODIFIED);
2544 update_all(game[gindex]);
2545 break;
2546 case ']':
2547 case '[':
2548 case '/':
2549 if (history_total(game[gindex].hp) < 2)
2550 break;
2551
2552 n = 0;
2553
2554 if (!*moveexp || c == '/') {
2555 if ((tmp = get_input(FIND_REGEXP, moveexp, 1, 1, NULL, NULL, NULL, 0, -1)) == NULL)
2556 break;
2557
2558 strncpy(moveexp, tmp, sizeof(moveexp));
2559 n = 1;
2560 }
2561
2562 if ((n = find_move_exp(game[gindex], moveexp, n,
2563 (c == '[') ? 0 : 1, (keycount) ? keycount : 1))
2564 == -1)
2565 break;
2566
2567 game[gindex].hindex = n;
2568 history_update_board(&game[gindex], game[gindex].b, game[gindex].hindex);
2569 update_all(game[gindex]);
2570 update_cursor(game[gindex], game[gindex].hindex);
2571 break;
2572 case 'v':
2573 view_annotation(*game[gindex].hp[game[gindex].hindex]);
2574 break;
2575 case 'V':
2576 if (game[gindex].hindex - 1 >= 0)
2577 view_annotation(*game[gindex].hp[game[gindex].hindex - 1]);
2578 break;
2579 case '-':
2580 case '+':
2581 rav_next_prev(&game[gindex], game[gindex].b, (c == '-') ? 0 : 1);
2582 update_all(game[gindex]);
2583 break;
2584 case 'j':
2585 if (history_total(game[gindex].hp) < 2)
2586 break;
2587
2588 /* FIXME field validation
2589 if ((tmp = get_input(GAME_HISTORY_JUMP_TITLE, NULL, 1, 1,
2590 NULL, NULL, NULL, 0, FIELD_TYPE_INTEGER, 1, 0,
2591 game[gindex].htotal)) == NULL)
2592 break;
2593 */
2594
2595 if (!keycount) {
2596 if ((tmp = get_input(GAME_HISTORY_JUMP_TITLE, NULL, 1, 1,
2597 NULL, NULL, NULL, 0, -1)) == NULL)
2598 break;
2599
2600 if (!isinteger(tmp))
2601 break;
2602
2603 n = atoi(tmp);
2604 }
2605 else
2606 n = keycount;
2607
2608 if (n < 0 || n > (history_total(game[gindex].hp) / 2))
2609 break;
2610
2611 game[gindex].hindex = (n) ? n * 2 - 1 : n * 2;
2612 history_update_board(&game[gindex], game[gindex].b,
2613 game[gindex].hindex);
2614 update_all(game[gindex]);
2615 update_cursor(game[gindex], game[gindex].hindex);
2616 break;
2617 default:
2618 break;
2619 }
2620 }
2621
2622 static void cleanup_all_games()
2623 {
2624 int i;
2625
2626 for (i = 0; i < gtotal; i++) {
2627 struct user_data_s *d;
2628
2629 if (game[i].data) {
2630 stop_engine(&game[i]);
2631 d = game[i].data;
2632
2633 if (d->fd[ICS_FD] > 2)
2634 close(d->fd[ICS_FD]);
2635
2636 free(game[i].data);
2637 game[i].data = NULL;
2638 }
2639 }
2640 }
2641
2642 // Global and other keys.
2643 static int globalkeys(int c)
2644 {
2645 static char gameexp[255] = {0};
2646 FILE *fp;
2647 char *tmp, *p;
2648 int n, i;
2649 char tfile[FILENAME_MAX];
2650 struct user_data_s *d = game[gindex].data;
2651
2652 switch (c) {
2653 case 'h':
2654 if (game[gindex].mode != MODE_HISTORY) {
2655 if (!history_total(game[gindex].hp) ||
2656 (d && d->status == ENGINE_THINKING))
2657 return 1;
2658
2659 game[gindex].mode = MODE_HISTORY;
2660 history_update_board(&game[gindex], game[gindex].b, history_total(game[gindex].hp));
2661 return 1;
2662 }
2663
2664 // FIXME
2665 if (TEST_FLAG(game[gindex].flags, GF_BLACK_OPENING)) {
2666 cmessage(NULL, ANYKEY, "%s", E_RESUME_BLACK);
2667 return 1;
2668 }
2669
2670 // FIXME Resuming from previous history could append to a RAV.
2671 if (game[gindex].hindex != history_total(game[gindex].hp)) {
2672 if (!pushkey) {
2673 if ((c = message(NULL, YESNO, "%s",
2674 GAME_RESUME_HISTORY_TEXT)) != 'y')
2675 return 1;
2676 }
2677 }
2678 else {
2679 if (TEST_FLAG(game[gindex].flags, GF_GAMEOVER))
2680 return 1;
2681 }
2682
2683 if (!noengine && (!d || d->status == ENGINE_OFFLINE)) {
2684 if (start_chess_engine(&game[gindex]) < 0)
2685 return 1;
2686
2687 pushkey = 'h';
2688 return 1;
2689 }
2690
2691 pushkey = 0;
2692 oldhistorytotal = history_total(game[gindex].hp);
2693 game[gindex].mode = MODE_PLAY;
2694 update_all(game[gindex]);
2695 return 1;
2696 case '>':
2697 case '<':
2698 game_next_prev(game[gindex], (c == '>') ? 1 : 0, (keycount) ?
2699 keycount : 1);
2700
2701 if (delete_count) {
2702 markend = gindex;
2703 pushkey = 'x';
2704 delete_count = 0;
2705 }
2706
2707 if (game[gindex].mode != MODE_EDIT) {
2708 history_update_board(&game[gindex], game[gindex].b, history_total(game[gindex].hp));
2709 update_cursor(game[gindex], game[gindex].hindex);
2710 }
2711 update_all(game[gindex]);
2712 update_tag_window(game[gindex].tag);
2713 return 1;
2714 // Not sure whether to keep these.
2715 case '!': c_row = 1; return 1;
2716 case '@': c_row = 2; return 1;
2717 case '#': c_row = 3; return 1;
2718 case '$': c_row = 4; return 1;
2719 case '%': c_row = 5; return 1;
2720 case '^': c_row = 6; return 1;
2721 case '&': c_row = 7; return 1;
2722 case '*': c_row = 8; return 1;
2723 case 'A': c_col = 1; return 1;
2724 case 'B': c_col = 2; return 1;
2725 case 'C': c_col = 3; return 1;
2726 case 'D': c_col = 4; return 1;
2727 case 'E': c_col = 5; return 1;
2728 case 'F': c_col = 6; return 1;
2729 case 'G': c_col = 7; return 1;
2730 case 'H': c_col = 8; return 1;
2731 case '}':
2732 case '{':
2733 case '?':
2734 if (gtotal < 2)
2735 return 1;
2736
2737 if (!*gameexp || c == '?') {
2738 if ((tmp = get_input(GAME_FIND_EXPRESSION_TITLE, gameexp,
2739 1, 1, GAME_FIND_EXPRESSION_PROMPT, NULL,
2740 NULL, 0, -1)) == NULL)
2741 return 1;
2742
2743 strncpy(gameexp, tmp, sizeof(gameexp));
2744 }
2745
2746 if ((n = find_game_exp(gameexp, (c == '{') ? 0 : 1, (keycount)
2747 ? keycount : 1)) ==
2748 -1)
2749 return 1;
2750
2751 gindex = n;
2752
2753 if (history_total(game[gindex].hp))
2754 game[gindex].mode = MODE_HISTORY;
2755
2756 history_update_board(&game[gindex], game[gindex].b, history_total(game[gindex].hp));
2757 update_all(game[gindex]);
2758 update_tag_window(game[gindex].tag);
2759 return 1;
2760 case 'J':
2761 if (gtotal < 2)
2762 return 1;
2763
2764 /* FIXME field validation
2765 if ((tmp = get_input(GAME_JUMP_TITLE, NULL, 1, 1, NULL, NULL,
2766 NULL, 0, FIELD_TYPE_INTEGER, 1, 1, gtotal))
2767 == NULL)
2768 return 1;
2769 */
2770
2771 if (!keycount) {
2772 if ((tmp = get_input(GAME_JUMP_TITLE, NULL, 1, 1, NULL,
2773 NULL, NULL, 0, -1)) == NULL)
2774 return 1;
2775
2776 if (!isinteger(tmp))
2777 return 1;
2778
2779 i = atoi(tmp);
2780 }
2781 else
2782 i = keycount;
2783
2784 if (--i > gtotal - 1 || i < 0)
2785 return 1;
2786
2787 gindex = i;
2788 history_update_board(&game[gindex], game[gindex].b, history_total(game[gindex].hp));
2789 update_cursor(game[gindex], game[gindex].hindex);
2790 update_all(game[gindex]);
2791 update_tag_window(game[gindex].tag);
2792 return 1;
2793 case 'x':
2794 pushkey = 0;
2795
2796 if (gtotal < 2)
2797 return 1;
2798
2799 if (keycount && !delete_count) {
2800 markstart = gindex;
2801 delete_count = 1;
2802 update_status_notify(game[gindex], "%s (delete)",
2803 status.notify);
2804 return 1;
2805 }
2806
2807 if (markstart >= 0 && markend >= 0) {
2808 if (markstart > markend) {
2809 i = markstart;
2810 markstart = markend;
2811 markend = i;
2812 }
2813
2814 for (i = markstart; i <= markend; i++) {
2815 if (toggle_delete_flag(i))
2816 return 1;
2817 }
2818 }
2819 else {
2820 if (toggle_delete_flag(gindex))
2821 return 1;
2822 }
2823
2824 markstart = markend = -1;
2825 update_status_window(game[gindex]);
2826 return 1;
2827 case 'X':
2828 if (gtotal < 2) {
2829 cmessage(NULL, ANYKEY, "%s", E_DELETE_GAME);
2830 return 1;
2831 }
2832
2833 tmp = NULL;
2834
2835 for (i = n = 0; i < gtotal; i++) {
2836 if (TEST_FLAG(game[i].flags, GF_DELETE))
2837 n++;
2838 }
2839
2840 if (!n)
2841 tmp = GAME_DELETE_GAME_TEXT;
2842 else {
2843 if (n == gtotal) {
2844 cmessage(NULL, ANYKEY, "%s", E_DELETE_GAME);
2845 return 1;
2846 }
2847
2848 tmp = GAME_DELETE_ALL_TEXT;
2849 }
2850
2851 if (config.deleteprompt) {
2852 if ((c = cmessage(NULL, YESNO, "%s", tmp)) != 'y')
2853 return 1;
2854 }
2855
2856 delete_game((!n) ? gindex : -1);
2857
2858 if (history_total(game[gindex].hp))
2859 game[gindex].mode = MODE_HISTORY;
2860
2861 history_update_board(&game[gindex], game[gindex].b, history_total(game[gindex].hp));
2862 update_all(game[gindex]);
2863 update_tag_window(game[gindex].tag);
2864 return 1;
2865 case 'T':
2866 edit_save_tags(&game[gindex]);
2867 update_all(game[gindex]);
2868 update_tag_window(game[gindex].tag);
2869 return 1;
2870 case 't':
2871 edit_tags(game[gindex], game[gindex].b, 0);
2872 return 1;
2873 case 'r':
2874 if ((tmp = get_input(GAME_LOAD_TITLE, NULL, 1, 1,
2875 BROWSER_PROMPT, browse_directory, NULL, '\t',
2876 -1)) == NULL)
2877 return 1;
2878
2879 if ((tmp = word_expand(tmp)) == NULL)
2880 break;
2881
2882 if ((fp = pgn_open(tmp)) == NULL) {
2883 cmessage(ERROR, ANYKEY, "%s\n%s", tmp, strerror(errno));
2884 return 1;
2885 }
2886
2887 if (pgn_parse(fp))
2888 return 1;
2889
2890 strncpy(loadfile, tmp, sizeof(loadfile));
2891
2892 if (history_total(game[gindex].hp))
2893 game[gindex].mode = MODE_HISTORY;
2894
2895 history_update_board(&game[gindex], game[gindex].b, history_total(game[gindex].hp));
2896 update_all(game[gindex]);
2897 update_tag_window(game[gindex].tag);
2898 return 1;
2899 case 'S':
2900 case 's':
2901 i = -1;
2902
2903 if (gtotal > 1) {
2904 n = message(NULL, GAME_SAVE_MULTI_PROMPT, "%s",
2905 GAME_SAVE_MULTI_TEXT);
2906
2907 if (n == 'c')
2908 i = gindex;
2909 else if (n == 'a')
2910 i = -1;
2911 else {
2912 update_status_notify(game[gindex], "%s", NOTIFY_SAVE_ABORTED);
2913 return 1;
2914 }
2915 }
2916
2917 if ((tmp = get_input(GAME_SAVE_TITLE, loadfile, 1, 1,
2918 BROWSER_PROMPT, browse_directory, NULL,
2919 '\t', -1)) == NULL) {
2920 update_status_notify(game[gindex], "%s", NOTIFY_SAVE_ABORTED);
2921 return 1;
2922 }
2923
2924 if ((tmp = word_expand(tmp)) == NULL)
2925 break;
2926
2927 if (pgn_is_compressed(tmp)) {
2928 snprintf(tfile, sizeof(tfile), "%s.pgn", tmp);
2929 tmp = tfile;
2930 }
2931 else {
2932 if ((p = strchr(tmp, '.')) != NULL) {
2933 if (strcmp(p, ".pgn") != 0) {
2934 snprintf(tfile, sizeof(tfile), "%s.pgn", tmp);
2935 tmp = tfile;
2936 }
2937 }
2938 else {
2939 snprintf(tfile, sizeof(tfile), "%s.pgn", tmp);
2940 tmp = tfile;
2941 }
2942 }
2943
2944 if (save_pgn(tmp, 0, i)) {
2945 update_status_notify(game[gindex], "%s", NOTIFY_SAVE_FAILED);
2946 return 1;
2947 }
2948
2949 update_status_notify(game[gindex], "%s", NOTIFY_SAVED);
2950 update_all(game[gindex]);
2951 return 1;
2952 case KEY_F(1):
2953 n = 0;
2954
2955 while (n != 'q') {
2956 n = help(GAME_HELP_INDEX_TITLE, GAME_HELP_INDEX_PROMPT,
2957 mainhelp);
2958
2959 switch (n) {
2960 case 'h':
2961 help(GAME_HELP_HISTORY_TITLE, ANYKEY, historyhelp);
2962 return 1;
2963 case 'p':
2964 help(GAME_HELP_PLAY_TITLE, ANYKEY, playhelp);
2965 return 1;
2966 case 'e':
2967 help(GAME_HELP_EDIT_TITLE, ANYKEY, edithelp);
2968 return 1;
2969 case 'g':
2970 help(GAME_HELP_GAME_TITLE, ANYKEY, gamehelp);
2971 return 1;
2972 default:
2973 n = 'q';
2974 return 1;
2975 }
2976 }
2977
2978 return 1;
2979 case 'n':
2980 case 'N':
2981 if (c == 'N') {
2982 if (cmessage(NULL, YESNO, "%s", GAME_NEW_PROMPT) != 'y')
2983 return 1;
2984 }
2985
2986 if (c == 'n') {
2987 pgn_new_game();
2988 add_custom_tags(&game[gindex].tag);
2989 }
2990 else {
2991 cleanup_all_games();
2992 pgn_parse(NULL);
2993 add_custom_tags(&game[gindex].tag);
2994 pgn_init_board(game[gindex].b);
2995 }
2996
2997 game[gindex].mode = MODE_PLAY;
2998 c_row = (game[gindex].side == WHITE) ? 2 : 7;
2999 c_col = 4;
3000 update_status_notify(game[gindex], NULL);
3001 update_all(game[gindex]);
3002 update_tag_window(game[gindex].tag);
3003 return 1;
3004 case CTRL('L'):
3005 endwin();
3006 keypad(boardw, TRUE);
3007 refresh_all();
3008 return 1;
3009 case KEY_ESCAPE:
3010 sp.icon = sp.row = sp.col = 0;
3011 markend = markstart = 0;
3012
3013 if (keycount) {
3014 keycount = 0;
3015 update_status_notify(game[gindex], NULL);
3016 }
3017
3018 if (config.validmoves)
3019 board_reset_valid_moves(game[gindex].b);
3020
3021 return 1;
3022 case '0' ... '9':
3023 n = c - '0';
3024
3025 if (keycount)
3026 keycount = keycount * 10 + n;
3027 else
3028 keycount = n;
3029
3030 update_status_notify(game[gindex], "Repeat %i", keycount);
3031 return -1;
3032 case KEY_UP:
3033 if (game[gindex].mode == MODE_HISTORY)
3034 return 0;
3035
3036 if (keycount) {
3037 c_row += keycount;
3038 pushkey = '\n';
3039 }
3040 else
3041 c_row++;
3042
3043 if (c_row > 8)
3044 c_row = 1;
3045
3046 return 1;
3047 case KEY_DOWN:
3048 if (game[gindex].mode == MODE_HISTORY)
3049 return 0;
3050
3051 if (keycount) {
3052 c_row -= keycount;
3053 pushkey = '\n';
3054 update_status_notify(game[gindex], NULL);
3055 }
3056 else
3057 c_row--;
3058
3059 if (c_row < 1)
3060 c_row = 8;
3061
3062 return 1;
3063 case KEY_LEFT:
3064 if (game[gindex].mode == MODE_HISTORY)
3065 return 0;
3066
3067 if (keycount) {
3068 c_col -= keycount;
3069 pushkey = '\n';
3070 }
3071 else
3072 c_col--;
3073
3074 if (c_col < 1)
3075 c_col = 8;
3076
3077 return 1;
3078 case KEY_RIGHT:
3079 if (game[gindex].mode == MODE_HISTORY)
3080 return 0;
3081
3082 if (keycount) {
3083 c_col += keycount;
3084 pushkey = '\n';
3085 }
3086 else
3087 c_col++;
3088
3089 if (c_col > 8)
3090 c_col = 1;
3091
3092 return 1;
3093 case 'e':
3094 if (game[gindex].mode != MODE_EDIT && game[gindex].mode !=
3095 MODE_PLAY)
3096 return 1;
3097
3098 // Don't edit a running game (for now).
3099 if (history_total(game[gindex].hp))
3100 return 1;
3101
3102 if (game[gindex].mode != MODE_EDIT) {
3103 pgn_init_fen_board(&game[gindex], game[gindex].b, NULL);
3104 board_details++;
3105 game[gindex].mode = MODE_EDIT;
3106 update_all(game[gindex]);
3107 return 1;
3108 }
3109
3110 board_details--;
3111 pgn_add_tag(&game[gindex].tag, "FEN",
3112 pgn_game_to_fen(game[gindex], game[gindex].b));
3113 pgn_add_tag(&game[gindex].tag, "SetUp", "1");
3114 pgn_sort_tags(game[gindex].tag);
3115 game[gindex].mode = MODE_PLAY;
3116 update_all(game[gindex]);
3117 return 1;
3118 case 'Q':
3119 quit = 1;
3120 return 1;
3121 case KEY_RESIZE:
3122 do_window_resize();
3123 return 1;
3124 #ifdef DEBUG
3125 case 'O':
3126 message("DEBUG BOARD", ANYKEY, "%s", debug_board(game[gindex].b));
3127 return 1;
3128 #endif
3129 case 0:
3130 default:
3131 break;
3132 }
3133
3134 return 0;
3135 }
3136
3137 void game_loop()
3138 {
3139 int error_recover = 0;
3140
3141 c_row = 2, c_col = 5;
3142 gindex = gtotal - 1;
3143
3144 if (history_total(game[gindex].hp))
3145 game[gindex].mode = MODE_HISTORY;
3146 else
3147 game[gindex].mode = MODE_PLAY;
3148
3149 if (game[gindex].mode == MODE_HISTORY) {
3150 history_update_board(&game[gindex], game[gindex].b,
3151 history_total(game[gindex].hp));
3152 update_cursor(game[gindex], game[gindex].hindex);
3153 }
3154
3155 update_status_notify(game[gindex], "%s", GAME_HELP_PROMPT);
3156 movestep = 2;
3157 paused = 1; //FIXME clock
3158 flushinp();
3159 update_all(game[gindex]);
3160 update_tag_window(game[gindex].tag);
3161
3162 while (!quit) {
3163 int c = 0;
3164 int n = 0, i;
3165 char fdbuf[8192] = {0};
3166 int len;
3167 struct timeval tv = {0, 0};
3168 fd_set rfds, wfds;
3169 struct user_data_s *d = NULL;
3170
3171 FD_ZERO(&rfds);
3172 FD_ZERO(&wfds);
3173
3174 for (i = 0; i < gtotal; i++) {
3175 if (game[i].data) {
3176 d = game[i].data;
3177
3178 if (d->fd[ENGINE_IN_FD] > 2) {
3179 if (d->fd[ENGINE_IN_FD] > n)
3180 n = d->fd[ENGINE_IN_FD];
3181
3182 FD_SET(d->fd[ENGINE_IN_FD], &rfds);
3183 }
3184
3185 if (d->fd[ICS_FD] > 2) {
3186 if (d->fd[ICS_FD] > n)
3187 n = d->fd[ICS_FD];
3188
3189 FD_SET(d->fd[ICS_FD], &rfds);
3190 FD_SET(d->fd[ICS_FD], &wfds);
3191 }
3192 }
3193 }
3194
3195 if (n) {
3196 if ((n = select(n + 1, &rfds, &wfds, NULL, &tv)) > 0) {
3197 for (i = 0; i < gtotal; i++) {
3198 if (game[i].data) {
3199 d = game[i].data;
3200
3201 if (FD_ISSET(d->fd[ENGINE_IN_FD], &rfds)) {
3202 len = read(d->fd[ENGINE_IN_FD], fdbuf,
3203 sizeof(fdbuf));
3204
3205 if (len == -1) {
3206 if (errno != EAGAIN) {
3207 cmessage(ERROR, ANYKEY, "Attempt #%i. read(): %s",
3208 ++error_recover, strerror(errno));
3209 continue;
3210 }
3211 }
3212 else {
3213 if (len) {
3214 parse_engine_output(&game[gindex], fdbuf);
3215 update_all(game[gindex]);
3216 }
3217 }
3218 }
3219 }
3220 }
3221 }
3222 else {
3223 if (n == -1)
3224 cmessage(ERROR, ANYKEY, "select(): %s", strerror(errno));
3225 else {
3226 /* timeout */
3227 }
3228 }
3229 }
3230
3231 error_recover = 0;
3232 draw_board(&game[gindex], board_details);
3233 wmove(boardw, ROWTOMATRIX(c_row), COLTOMATRIX(c_col));
3234
3235 if (!paused) {
3236 }
3237
3238 refresh_all();
3239
3240 if (pushkey)
3241 c = pushkey;
3242 else {
3243 if ((c = wgetch(boardw)) == ERR)
3244 continue;
3245 }
3246
3247 if (!keycount && status.notify)
3248 update_status_notify(game[gindex], NULL);
3249
3250
3251 if ((n = globalkeys(c)) == 1) {
3252 keycount = 0;
3253 continue;
3254 }
3255 else if (n == -1)
3256 continue;
3257
3258 switch (game[gindex].mode) {
3259 case MODE_EDIT:
3260 editmode_keys(c);
3261 break;
3262 case MODE_PLAY:
3263 playmode_keys(c);
3264 break;
3265 case MODE_HISTORY:
3266 historymode_keys(c);
3267 break;
3268 default:
3269 break;
3270 }
3271
3272 keycount = 0;
3273 }
3274 }
3275
3276 void usage(const char *pn, int ret)
3277 {
3278 fprintf((ret) ? stderr : stdout, "%s",
3279 "Usage: cboard [-hvNE] [-VtRS] [-p <file>]\n"
3280 " -p Load PGN file.\n"
3281 " -V Validate a game file.\n"
3282 " -S Validate and output a PGN formatted game.\n"
3283 " -R Like -S but write a reduced PGN formatted game.\n"
3284 " -t Also write custom PGN tags from config file.\n"
3285 " -N Don't enable the chess engine (two human players).\n"
3286 " -E Stop processing on file parsing error (overrides config).\n"
3287 " -v Version information.\n"
3288 " -h This help text.\n");
3289
3290 exit(ret);
3291 }
3292
3293 void cleanup_all()
3294 {
3295 cleanup_all_games();
3296 pgn_free_all();
3297 del_panel(boardp);
3298 del_panel(historyp);
3299 del_panel(statusp);
3300 del_panel(tagp);
3301 delwin(boardw);
3302 delwin(historyw);
3303 delwin(statusw);
3304 delwin(tagw);
3305 endwin();
3306 }
3307
3308 void catch_signal(int which)
3309 {
3310 switch (which) {
3311 case SIGINT:
3312 case SIGPIPE:
3313 if (which == SIGPIPE && quit)
3314 break;
3315
3316 if (which == SIGPIPE)
3317 cmessage(NULL, ANYKEY, "%s", E_BROKEN_PIPE);
3318
3319 cleanup_all();
3320 exit(EXIT_FAILURE);
3321 break;
3322 case SIGSTOP:
3323 savetty();
3324 break;
3325 case SIGCONT:
3326 resetty();
3327 keypad(boardw, TRUE);
3328 curs_set(0);
3329 cbreak();
3330 noecho();
3331 break;
3332 default:
3333 break;
3334 }
3335 }
3336
3337 static void set_defaults()
3338 {
3339 filetype = NO_FILE;
3340 set_config_defaults();
3341 }
3342
3343 int main(int argc, char *argv[])
3344 {
3345 int opt;
3346 struct stat st;
3347 char buf[FILENAME_MAX];
3348 char datadir[FILENAME_MAX];
3349 int ret = EXIT_SUCCESS;
3350 int validate_only = 0, validate_and_write = 0, reduced = 0;
3351 int write_custom_tags = 0;
3352 FILE *fp;
3353
3354 if ((config.pwd = getpwuid(getuid())) == NULL)
3355 err(EXIT_FAILURE, "getpwuid()");
3356
3357 snprintf(datadir, sizeof(datadir), "%s/.cboard", config.pwd->pw_dir);
3358 snprintf(buf, sizeof(buf), "%s/cc.data", datadir);
3359 config.ccfile = strdup(buf);
3360 snprintf(buf, sizeof(buf), "%s/nag.data", datadir);
3361 config.nagfile = strdup(buf);
3362 snprintf(buf, sizeof(buf), "%s/agony.data", datadir);
3363 config.agonyfile = strdup(buf);
3364 snprintf(buf, sizeof(buf), "%s/config", datadir);
3365 config.configfile = strdup(buf);
3366 snprintf(buf, sizeof(buf), "%s/fifo", datadir);
3367 config.fifo = strdup(buf);
3368
3369 if (stat(datadir, &st) == -1) {
3370 if (errno == ENOENT) {
3371 if (mkdir(datadir, 0755) == -1)
3372 err(EXIT_FAILURE, "%s", datadir);
3373 }
3374 else
3375 err(EXIT_FAILURE, "%s", datadir);
3376
3377 stat(datadir, &st);
3378 }
3379
3380 if (!S_ISDIR(st.st_mode))
3381 errx(EXIT_FAILURE, "%s: %s", datadir, E_NOTADIR);
3382
3383 if (access(config.fifo, R_OK) == -1 && errno == ENOENT) {
3384 if (mkfifo(config.fifo, 0600) == -1)
3385 err(EXIT_FAILURE, "%s", config.fifo);
3386 }
3387
3388 set_defaults();
3389
3390 while ((opt = getopt(argc, argv, "ENVtSRhp:v")) != -1) {
3391 switch (opt) {
3392 case 't':
3393 write_custom_tags = 1;
3394 break;
3395 case 'E':
3396 config.stoponerror = 1;
3397 break;
3398 case 'N':
3399 noengine = 1;
3400 break;
3401 case 'R':
3402 reduced = 1;
3403 case 'S':
3404 validate_and_write = 1;
3405 case 'V':
3406 validate_only = 1;
3407 break;
3408 case 'v':
3409 printf("%s (%s)\n%s\n", PACKAGE_STRING, curses_version(),
3410 COPYRIGHT);
3411 exit(EXIT_SUCCESS);
3412 case 'p':
3413 filetype = PGN_FILE;
3414 strncpy(loadfile, optarg, sizeof(loadfile));
3415 break;
3416 case 'h':
3417 default:
3418 usage(argv[0], EXIT_SUCCESS);
3419 }
3420 }
3421
3422 if ((validate_only || validate_and_write) && !*loadfile)
3423 usage(argv[0], EXIT_FAILURE);
3424
3425 if (access(config.configfile, R_OK) == 0)
3426 parse_rcfile(config.configfile);
3427
3428 signal(SIGPIPE, catch_signal);
3429 signal(SIGCONT, catch_signal);
3430 signal(SIGSTOP, catch_signal);
3431 signal(SIGINT, catch_signal);
3432
3433 srandom(getpid());
3434
3435 switch (filetype) {
3436 case PGN_FILE:
3437 if ((fp = pgn_open(loadfile)) == NULL)
3438 err(EXIT_FAILURE, "%s", loadfile);
3439
3440 ret = pgn_parse(fp);
3441 break;
3442 case FEN_FILE:
3443 //ret = parse_fen_file(loadfile);
3444 break;
3445 case EPD_FILE: // Not implemented.
3446 case NO_FILE:
3447 default:
3448 // No file specified. Empty game.
3449 ret = pgn_parse(NULL);
3450 add_custom_tags(&game[gindex].tag);
3451 break;
3452 }
3453
3454 if (validate_only || validate_and_write) {
3455 if (validate_and_write) {
3456 int i;
3457
3458 for (i = 0; i < gtotal; i++) {
3459 if (write_custom_tags)
3460 add_custom_tags(&game[i].tag);
3461
3462 pgn_write(stdout, game[i]);
3463 }
3464 }
3465
3466 pgn_free_all();
3467 exit(ret);
3468 }
3469 else if (ret)
3470 exit(ret);
3471
3472 if (initscr() == NULL)
3473 errx(EXIT_FAILURE, "%s", E_INITCURSES);
3474 else
3475 curses_initialized = 1;
3476
3477 if (LINES < 24 || COLS < 80) {
3478 endwin();
3479 errx(EXIT_FAILURE, "Need at least an 80x24 terminal.");
3480 }
3481
3482 if (has_colors() == TRUE && start_color() == OK)
3483 init_color_pairs();
3484
3485 boardw = newwin(BOARD_HEIGHT, BOARD_WIDTH, 0, COLS - BOARD_WIDTH);
3486 boardp = new_panel(boardw);
3487 historyw = newwin(HISTORY_HEIGHT, HISTORY_WIDTH, LINES - HISTORY_HEIGHT,
3488 COLS - HISTORY_WIDTH);
3489 historyp = new_panel(historyw);
3490 statusw = newwin(STATUS_HEIGHT, STATUS_WIDTH, LINES - STATUS_HEIGHT, 0);
3491 statusp = new_panel(statusw);
3492 tagw = newwin(TAG_HEIGHT, TAG_WIDTH, 0, 0);
3493 tagp = new_panel(tagw);
3494 keypad(boardw, TRUE);
3495 // leaveok(boardw, TRUE);
3496 leaveok(tagw, TRUE);
3497 leaveok(statusw, TRUE);
3498 leaveok(historyw, TRUE);
3499 curs_set(0);
3500 cbreak();
3501 noecho();
3502 draw_window_decor();
3503 game_loop();
3504 cleanup_all();
3505 exit(EXIT_SUCCESS);
3506 }
A console/ncurses chess engine frontend and PGN editor.