?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Fix the engine_init and cbind configuration parameters.
[cboard.git] / src / cboard.c
blob7da73e9f9a6ec80301371d61b8898ec9a86efd09
1 /* vim:tw=78:ts=8:sw=4:set ft=c: */
2 /*
3 Copyright (C) 2002-2013 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 #ifdef HAVE_CONFIG_H
20 #include <config.h>
21 #endif
22
23 #include <stdio.h>
24 #include <stdlib.h>
25 #include <unistd.h>
26 #include <sys/types.h>
27 #include <sys/socket.h>
28 #include <sys/stat.h>
29 #include <string.h>
30 #include <errno.h>
31 #include <ctype.h>
32 #include <pwd.h>
33 #include <signal.h>
34 #include <time.h>
35 #include <err.h>
36 #include <locale.h>
37
38 #ifdef HAVE_STDARG_H
39 #include <stdarg.h>
40 #endif
41
42 #ifdef HAVE_SYS_WAIT_H
43 #include <sys/wait.h>
44 #endif
45
46 #ifdef HAVE_REGEX_H
47 #include <regex.h>
48 #endif
49
50 #ifdef WITH_LIBPERL
51 #include "perl-plugin.h"
52 #endif
53
54 #include "common.h"
55 #include "conf.h"
56 #include "window.h"
57 #include "message.h"
58 #include "colors.h"
59 #include "input.h"
60 #include "misc.h"
61 #include "engine.h"
62 #include "strings.h"
63 #include "menu.h"
64 #include "keys.h"
65 #include "rcfile.h"
66 #include "filebrowser.h"
67
68 #ifdef DEBUG
69 #include <debug.h>
70 #endif
71
72 #define COPYRIGHT "Copyright (C) 2002-2013 " PACKAGE_BUGREPORT
73 #define LINE_GRAPHIC(c) ((!config.linegraphics) ? ' ' : c)
74 #define ROWTOMATRIX(r) ((8 - r) * 2 + 2 - 1)
75 #define COLTOMATRIX(c) ((c == 1) ? 1 : c * 4 - 3)
76 #define STATUS_HEIGHT 12
77 #define MEGA_BOARD (LINES >= 50 && COLS >= 144)
78 #define BOARD_HEIGHT_MB 50
79 #define BOARD_WIDTH_MB 98
80 #define STATUS_WIDTH_MB (COLS - BOARD_WIDTH_MB)
81 #define TAG_HEIGHT_MB 31
82 #define TAG_WIDTH_MB (COLS - BOARD_WIDTH_MB)
83 #define HISTORY_HEIGHT_MB (LINES - (STATUS_HEIGHT + TAG_HEIGHT_MB + 1))
84 #define HISTORY_WIDTH_MB (COLS - BOARD_WIDTH_MB)
85 #define BIG_BOARD (LINES >= 40 && COLS >= 112)
86 #define BOARD_HEIGHT ((MEGA_BOARD) ? BOARD_HEIGHT_MB : (BIG_BOARD) ? 34 : 18)
87 #define BOARD_WIDTH ((MEGA_BOARD) ? BOARD_WIDTH_MB : (BIG_BOARD) ? 66 : 34)
88 #define STATUS_WIDTH ((MEGA_BOARD) ? STATUS_WIDTH_MB : COLS - BOARD_WIDTH)
89 #define TAG_HEIGHT ((MEGA_BOARD) ? TAG_HEIGHT_MB : LINES - STATUS_HEIGHT - 1)
90 #define TAG_WIDTH ((MEGA_BOARD) ? TAG_WIDTH_MB : COLS - BOARD_WIDTH)
91 #define HISTORY_HEIGHT ((MEGA_BOARD) ? HISTORY_HEIGHT_MB : LINES - BOARD_HEIGHT)
92 #define HISTORY_WIDTH ((MEGA_BOARD) ? HISTORY_WIDTH_MB : COLS - STATUS_WIDTH)
93 #define MAX_VALUE_WIDTH (COLS - 8)
94
95 enum {
96 UP, DOWN, LEFT, RIGHT
97 };
98
99 static WINDOW *boardw;
100 static PANEL *boardp;
101 static WINDOW *tagw;
102 static PANEL *tagp;
103 static WINDOW *statusw;
104 static PANEL *statusp;
105 static WINDOW *historyw;
106 static PANEL *historyp;
107 static WINDOW *loadingw;
108 static PANEL *loadingp;
109 static WINDOW *enginew;
110 static PANEL *enginep;
111
112 static char gameexp[255];
113 static char moveexp[255];
114 static struct itimerval clock_timer;
115 static int delete_count = 0;
116 static int markstart = -1, markend = -1;
117 static int keycount;
118 static char loadfile[FILENAME_MAX];
119 static int quit;
120 static wint_t input_c;
121
122 // Loaded filename from the command line or from the file input dialog.
123 static int filetype;
124 enum {
125 FILE_NONE, FILE_PGN, FILE_FEN, FILE_EPD
126 };
127
128 static char **nags;
129 static int nag_total;
130 static int macro_match;
131
132 // Primer movimiento de juego cargado
133 // First move loaded game
134 static char fm_loaded_file = FALSE;
135 // Movimiento resultado de la función 'do_play_go'
136 // Movement function result 'do_play_go'
137 static int go_move = 0;
138 // Controla rotación de tablero
139 // Rotation control board
140 static int rotate = FALSE;
141
142 static int COLS_OLD, LINES_OLD;
143
144 // Status window.
145 static struct {
146 wchar_t *notify; // The status window notification line buffer.
147 } status;
148
149 static int curses_initialized;
150
151 // When in history mode a full step is to the next move of the same playing
152 // side. Half stepping is alternating sides.
153 static int movestep;
154
155 static wchar_t *w_pawn_wchar;
156 static wchar_t *w_rook_wchar;
157 static wchar_t *w_bishop_wchar;
158 static wchar_t *w_knight_wchar;
159 static wchar_t *w_queen_wchar;
160 static wchar_t *w_king_wchar;
161 static wchar_t *b_pawn_wchar;
162 static wchar_t *b_rook_wchar;
163 static wchar_t *b_bishop_wchar;
164 static wchar_t *b_knight_wchar;
165 static wchar_t *b_queen_wchar;
166 static wchar_t *b_king_wchar;
167 static wchar_t *empty_wchar;
168 static wchar_t *enpassant_wchar;
169
170 static wchar_t *yes_wchar;
171 static wchar_t *all_wchar; // do_save_game_overwrite_confirm()
172 static wchar_t *overwrite_wchar; // do_save_game_overwrite_confirm()
173 static wchar_t *resume_wchar; // do_history_mode_confirm()
174 static wchar_t *current_wchar; // do_game_save_multi_confirm()
175 static wchar_t *append_wchar; // save_pgn()
176
177 static const char piece_chars[] = "PpRrNnBbQqKkxx";
178 static char *translatable_tag_names[7];
179 static const char *f_pieces[] = {
180 " ", // 0
181 " O ",
182 " /_\\ ",
183 " |-|-| ", // 3
184 " ] [ ",
185 " /___\\ ",
186 " /?M ", // 6
187 " (@/)) ",
188 " /__))",
189 " O ", // 9
190 " (+) ",
191 " /_\\ ",
192 "•°°°°°•",// 12
193 " \\\\|// ",
194 " |___| ",
195 " __+__ ", // 15
196 "(__|__)",
197 " |___| ",
198 " \\ / ", // 18
199 " X ",
200 " / \\ "
201 };
202
203 static const bool cb[8][8] = {
204 {1,0,1,0,1,0,1,0},
205 {0,1,0,1,0,1,0,1},
206 {1,0,1,0,1,0,1,0},
207 {0,1,0,1,0,1,0,1},
208 {1,0,1,0,1,0,1,0},
209 {0,1,0,1,0,1,0,1},
210 {1,0,1,0,1,0,1,0},
211 {0,1,0,1,0,1,0,1}
212 };
213
214 static void free_userdata_once(GAME g);
215
216 // Posición por rotación de tablero.
217 // Rotation board position.
218 static void rotate_position(int p)
219 {
220 struct userdata_s *d = gp->data;
221 char fr, fc;
222 char fr2 = 8, fc2 = 8;
223
224 for (fr = 1; fr < 9; fr++) {
225 if (fr2 < 1)
226 fr2 = 8;
227 for (fc = 1; fc < 9; fc++){
228 if (fc2 < 1)
229 fc2 = 8;
230 if (p == CURSOR_POSITION &&
231 d->c_row == fr && d->c_col == fc) {
232 d->c_row = fr2;
233 d->c_col = fc2;
234 return;
235 }
236 else if (p == SP_POSITION &&
237 d->sp.row == fr && d->sp.col == fc) {
238 d->sp.row = fr2;
239 d->sp.col = fc2;
240 return;
241 }
242 else if (p == SPS_POSITION &&
243 d->sp.srow == fr && d->sp.scol == fc) {
244 d->sp.srow = fr2;
245 d->sp.scol = fc2;
246 return;
247 }
248 fc2--;
249 }
250 fr2--;
251 }
252 }
253
254 void update_cursor(GAME g, int idx)
255 {
256 char *p;
257 int len;
258 int t = pgn_history_total(g->hp);
259 struct userdata_s *d = g->data;
260
261 /*
262 * If not deincremented then r and c would be the next move.
263 */
264 idx--;
265
266 if (idx > t || idx < 0 || !t || !g->hp[idx]->move) {
267 d->c_row = 2, d->c_col = 5;
268 goto historyrotate;
269 // return;
270 }
271
272 p = g->hp[idx]->move;
273 len = strlen(p);
274
275 if (*p == 'O') {
276 if (len <= 4)
277 d->c_col = rotate ? 3 : 7;
278 else
279 d->c_col = rotate ? 6 : 3;
280
281 if (rotate)
282 d->c_row = (g->turn == WHITE) ? 1 : 8;
283 else
284 d->c_row = (g->turn == WHITE) ? 8 : 1;
285
286 return;
287 }
288
289 p += len;
290
291 while (!isdigit(*p))
292 p--;
293
294 d->c_row = RANKTOINT(*p--);
295 d->c_col = FILETOINT(*p);
296
297 historyrotate:
298 if (d->mode == MODE_HISTORY && rotate)
299 rotate_position(CURSOR_POSITION);
300 }
301
302 static int init_nag()
303 {
304 FILE *fp;
305 char line[LINE_MAX];
306 int i = 0;
307
308 if ((fp = fopen(config.nagfile, "r")) == NULL) {
309 cmessage(ERROR_STR, ANY_KEY_STR, "%s: %s", config.nagfile, strerror(errno));
310 return 1;
311 }
312
313 nags = Realloc(nags, (i+2) * sizeof(char *));
314 nags[i++] = strdup(_("none"));
315 nags[i] = NULL;
316
317 while (!feof(fp)) {
318 if (fscanf(fp, " %[^\n] ", line) == 1) {
319 nags = Realloc(nags, (i + 2) * sizeof(char *));
320 nags[i++] = strdup(line);
321 }
322 }
323
324 nags[i] = NULL;
325 nag_total = i;
326 return 0;
327 }
328
329 void edit_nag_toggle_item(struct menu_input_s *m)
330 {
331 struct input_s *in = m->data;
332 struct input_data_s *id = in->data;
333 HISTORY *h = id->data;
334 int i;
335
336 if (m->selected == 0) {
337 for (i = 0; i < MAX_PGN_NAG; i++)
338 h->nag[i] = 0;
339
340 for (i = 0; m->items[i]; i++)
341 m->items[i]->selected = 0;
342
343 return;
344 }
345
346 for (i = 0; i < MAX_PGN_NAG; i++) {
347 if (h->nag[i] == m->selected)
348 h->nag[i] = m->selected = 0;
349 else {
350 if (!h->nag[i]) {
351 h->nag[i] = m->selected;
352 break;
353 }
354 }
355 }
356 }
357
358 void edit_nag_save(struct menu_input_s *m)
359 {
360 pushkey = -1;
361 }
362
363 void edit_nag_help(struct menu_input_s *m)
364 {
365 message(_("NAG Menu Keys"), ANY_KEY_STR, "%s",
366 _ (
367 " UP/DOWN - previous/next menu item\n"
368 " HOME/END - first/last menu item\n"
369 " PGDN/PGUP - next/previous page\n"
370 " a-zA-Z0-9 - jump to item\n"
371 " SPACE - toggle selected item\n"
372 " CTRL-X - quit with changes"
373 ));
374 }
375
376 struct menu_item_s **get_nag_items(WIN *win)
377 {
378 int i, n;
379 struct menu_input_s *m = win->data;
380 struct input_s *in = m->data;
381 struct input_data_s *id = in->data;
382 struct menu_item_s **items = m->items;
383 HISTORY *h = id->data;
384
385 if (items) {
386 for (i = 0; items[i]; i++)
387 free(items[i]);
388 }
389
390 for (i = 0; nags[i]; i++) {
391 items = Realloc(items, (i+2) * sizeof(struct menu_item_s *));
392 items[i] = Malloc(sizeof(struct menu_item_s));
393 items[i]->name = nags[i];
394 items[i]->value = NULL;
395
396 for (n = 0; n < MAX_PGN_NAG; n++) {
397 if (h->nag[n] == i) {
398 items[i]->selected = 1;
399 n = -1;
400 break;
401 }
402 }
403
404 if (n >= 0)
405 items[i]->selected = 0;
406 }
407
408 items[i] = NULL;
409 m->nofree = 1;
410 m->items = items;
411 return items;
412 }
413
414 void nag_print(WIN *win)
415 {
416 struct menu_input_s *m = win->data;
417
418 mvwprintw(win->w, m->print_line, 1, "%-*s", win->cols - 2, m->item->name);
419 }
420
421 void edit_nag(void *arg)
422 {
423 struct menu_key_s **keys = NULL;
424
425 if (!nags) {
426 if (init_nag())
427 return;
428 }
429
430 add_menu_key(&keys, ' ', edit_nag_toggle_item);
431 add_menu_key(&keys, CTRL_KEY('x'), edit_nag_save);
432 add_menu_key(&keys, KEY_F(1), edit_nag_help);
433 construct_menu(0, 0, -1, -1, _("Numeric Annotation Glyphs"), 1, get_nag_items, keys, arg,
434 nag_print, NULL);
435 return;
436 }
437
438 static void *view_nag(void *arg)
439 {
440 HISTORY *h = (HISTORY *)arg;
441 char buf[80];
442 char line[LINE_MAX] = {0};
443 int i = 0;
444
445 snprintf(buf, sizeof(buf), "%s \"%s\"", _("Viewing NAG for"), h->move);
446
447 if (!nags) {
448 if (init_nag())
449 return NULL;
450 }
451
452 for (i = 0; i < MAX_PGN_NAG; i++) {
453 char buf2[16];
454
455 if (!h->nag[i])
456 break;
457
458 if (h->nag[i] >= nag_total)
459 strncat(line, itoa(h->nag[i], buf2), sizeof(line)-1);
460 else
461 strncat(line, nags[h->nag[i]], sizeof(line)-1);
462
463 strncat(line, "\n", sizeof(line)-1);
464 }
465
466 line[strlen(line) - 1] = 0;
467 message(buf, ANY_KEY_STR, "%s", line);
468 return NULL;
469 }
470
471 void view_annotation(HISTORY *h)
472 {
473 char buf[MAX_SAN_MOVE_LEN + strlen(_("Viewing Annotation for")) + 4];
474 int nag = 0, comment = 0;
475
476 if (!h)
477 return;
478
479 if (h->comment && h->comment[0])
480 comment++;
481
482 if (h->nag[0])
483 nag++;
484
485 if (!nag && !comment)
486 return;
487
488 snprintf(buf, sizeof(buf), "%s \"%s\"", _("Viewing Annotation for"), h->move);
489
490 if (comment)
491 construct_message(buf, (nag) ? _("Any other key to continue") : ANY_KEY_STR, 0, 1,
492 (nag) ? _("Press 'n' to view NAG") : NULL,
493 (nag) ? view_nag : NULL, (nag) ? h : NULL, NULL,
494 (nag) ? 'n' : 0, 0, "%s", h->comment);
495 else
496 construct_message(buf, _("Any other key to continue"), 0, 1, _("Press 'n' to view NAG"), view_nag, h, NULL,
497 'n', 0, "%s", _("No comment text for this move"));
498 }
499
500 int do_game_write(char *filename, char *mode, int start, int end)
501 {
502 int i;
503 struct userdata_s *d;
504 PGN_FILE *pgn;
505
506 i = pgn_open(filename, mode, &pgn);
507
508 if (i == E_PGN_ERR) {
509 cmessage(ERROR_STR, ANY_KEY_STR, "%s\n%s", filename, strerror(errno));
510 return 1;
511 }
512 else if (i == E_PGN_INVALID) {
513 cmessage(ERROR_STR, ANY_KEY_STR, "%s\n%s", filename, _("Not a regular file"));
514 return 1;
515 }
516
517 for (i = (start == -1) ? 0 : start; i < end; i++) {
518 d = game[i]->data;
519 pgn_write(pgn, game[i]);
520 CLEAR_FLAG(d->flags, CF_MODIFIED);
521 }
522
523 if (pgn_close(pgn) != E_PGN_OK)
524 message(ERROR_STR, ANY_KEY_STR, "%s", strerror(errno));
525
526 if (start == -1) {
527 strncpy(loadfile, filename, sizeof(loadfile));
528 loadfile[sizeof(loadfile)-1] = 0;
529 }
530
531 return 0;
532 }
533
534 struct save_game_s {
535 char *filename;
536 char *mode;
537 int start;
538 int end;
539 };
540
541 void do_save_game_overwrite_confirm(WIN *win)
542 {
543 char *mode = "w";
544 struct save_game_s *s = win->data;
545 wchar_t str[] = { win->c, 0 };
546
547 if (!wcscmp (str, append_wchar))
548 mode = "a";
549 else if (!wcscmp (str, overwrite_wchar))
550 mode = "w";
551 else
552 goto done;
553
554 if (do_game_write(s->filename, mode, s->start, s->end))
555 update_status_notify(gp, "%s", _("Save game failed."));
556 else
557 update_status_notify(gp, "%s", _("Game saved."));
558
559 done:
560 free(s->filename);
561 free(s);
562 }
563
564 /* If the saveindex argument is -1, all games will be saved. Otherwise it's a
565 * game index number.
566 */
567 void save_pgn(char *filename, int saveindex)
568 {
569 char buf[FILENAME_MAX];
570 struct stat st;
571 int end = (saveindex == -1) ? gtotal : saveindex + 1;
572 struct save_game_s *s;
573
574 if (filename[0] != '/' && config.savedirectory) {
575 if (stat(config.savedirectory, &st) == -1) {
576 if (errno == ENOENT) {
577 if (mkdir(config.savedirectory, 0755) == -1) {
578 cmessage(ERROR_STR, ANY_KEY_STR, "%s: %s", config.savedirectory,
579 strerror(errno));
580 return;
581 }
582 }
583 else {
584 cmessage(ERROR_STR, ANY_KEY_STR, "%s: %s", config.savedirectory,
585 strerror(errno));
586 return;
587 }
588 }
589
590 stat(config.savedirectory, &st);
591
592 if (!S_ISDIR(st.st_mode)) {
593 cmessage(ERROR_STR, ANY_KEY_STR, "%s: %s", config.savedirectory, _("Not a directory."));
594 return;
595 }
596
597 snprintf(buf, sizeof(buf), "%s/%s", config.savedirectory, filename);
598 filename = buf;
599 }
600
601 if (access(filename, W_OK) == 0) {
602 s = Malloc(sizeof(struct save_game_s));
603 s->filename = strdup(filename);
604 s->start = saveindex;
605 s->end = end;
606 construct_message(NULL, _("What would you like to do?"), 0, 1, NULL,
607 NULL, s, do_save_game_overwrite_confirm, 0, 0,
608 "%s \"%s\"\nPress \"%ls\" to append to this file, \"%ls\" to overwrite or any other key to cancel.",
609 _("File exists:"), filename, append_wchar,
610 overwrite_wchar);
611 return;
612 }
613
614 if (do_game_write(filename, "a", saveindex, end))
615 update_status_notify(gp, "%s", _("Save game failed."));
616 else
617 update_status_notify(gp, "%s", _("Game saved."));
618 }
619
620 static int castling_state(GAME g, BOARD b, int row, int col, int piece, int mod)
621 {
622 if (pgn_piece_to_int(piece) == ROOK && col == 7
623 && row == 7 &&
624 (TEST_FLAG(g->flags, GF_WK_CASTLE) || mod) &&
625 pgn_piece_to_int(b[7][4].icon) == KING && isupper(piece)) {
626 if (mod)
627 TOGGLE_FLAG(g->flags, GF_WK_CASTLE);
628 return 1;
629 }
630 else if (pgn_piece_to_int(piece) == ROOK && col == 0
631 && row == 7 &&
632 (TEST_FLAG(g->flags, GF_WQ_CASTLE) || mod) &&
633 pgn_piece_to_int(b[7][4].icon) == KING && isupper(piece)) {
634 if (mod)
635 TOGGLE_FLAG(g->flags, GF_WQ_CASTLE);
636 return 1;
637 }
638 else if (pgn_piece_to_int(piece) == ROOK && col == 7
639 && row == 0 &&
640 (TEST_FLAG(g->flags, GF_BK_CASTLE) || mod) &&
641 pgn_piece_to_int(b[0][4].icon) == KING && islower(piece)) {
642 if (mod)
643 TOGGLE_FLAG(g->flags, GF_BK_CASTLE);
644 return 1;
645 }
646 else if (pgn_piece_to_int(piece) == ROOK && col == 0
647 && row == 0 &&
648 (TEST_FLAG(g->flags, GF_BQ_CASTLE) || mod) &&
649 pgn_piece_to_int(b[0][4].icon) == KING && islower(piece)) {
650 if (mod)
651 TOGGLE_FLAG(g->flags, GF_BQ_CASTLE);
652 return 1;
653 }
654 else if (pgn_piece_to_int(piece) == KING && col == 4
655 && row == 7 &&
656 (mod || (pgn_piece_to_int(b[7][7].icon) == ROOK &&
657 TEST_FLAG(g->flags, GF_WK_CASTLE))
658 ||
659 (pgn_piece_to_int(b[7][0].icon) == ROOK &&
660 TEST_FLAG(g->flags, GF_WQ_CASTLE))) && isupper(piece)) {
661 if (mod) {
662 if (TEST_FLAG(g->flags, GF_WK_CASTLE) ||
663 TEST_FLAG(g->flags, GF_WQ_CASTLE))
664 CLEAR_FLAG(g->flags, GF_WK_CASTLE|GF_WQ_CASTLE);
665 else
666 SET_FLAG(g->flags, GF_WK_CASTLE|GF_WQ_CASTLE);
667 }
668 return 1;
669 }
670 else if (pgn_piece_to_int(piece) == KING && col == 4
671 && row == 0 &&
672 (mod || (pgn_piece_to_int(b[0][7].icon) == ROOK &&
673 TEST_FLAG(g->flags, GF_BK_CASTLE))
674 ||
675 (pgn_piece_to_int(b[0][0].icon) == ROOK &&
676 TEST_FLAG(g->flags, GF_BQ_CASTLE))) && islower(piece)) {
677 if (mod) {
678 if (TEST_FLAG(g->flags, GF_BK_CASTLE) ||
679 TEST_FLAG(g->flags, GF_BQ_CASTLE))
680 CLEAR_FLAG(g->flags, GF_BK_CASTLE|GF_BQ_CASTLE);
681 else
682 SET_FLAG(g->flags, GF_BK_CASTLE|GF_BQ_CASTLE);
683 }
684 return 1;
685 }
686
687 return 0;
688 }
689
690 #define IS_ENPASSANT(c) (c == 'x') ? CP_BOARD_ENPASSANT : isupper(c) ? CP_BOARD_WHITE : CP_BOARD_BLACK
691 #define ATTRS(cp) (cp & (A_BOLD|A_STANDOUT|A_BLINK|A_DIM|A_UNDERLINE|A_INVIS|A_REVERSE))
692
693 static void
694 init_wchar_pieces ()
695 {
696 w_pawn_wchar = str_to_wchar (config.utf8_pieces ? "♙" : "P");
697 w_rook_wchar = str_to_wchar (config.utf8_pieces ? "♖" : "R");
698 w_bishop_wchar = str_to_wchar (config.utf8_pieces ? "♗" : "B");
699 w_knight_wchar = str_to_wchar (config.utf8_pieces ? "♘" : "N");
700 w_queen_wchar = str_to_wchar (config.utf8_pieces ? "♕" : "Q");
701 w_king_wchar = str_to_wchar (config.utf8_pieces ? "♔" : "K");
702 b_pawn_wchar = str_to_wchar (config.utf8_pieces ? "♟" : "p");
703 b_rook_wchar = str_to_wchar (config.utf8_pieces ? "♜" : "r");
704 b_bishop_wchar = str_to_wchar (config.utf8_pieces ? "♝" : "b");
705 b_knight_wchar = str_to_wchar (config.utf8_pieces ? "♞" : "n");
706 b_queen_wchar = str_to_wchar (config.utf8_pieces ? "♛" : "q");
707 b_king_wchar = str_to_wchar (config.utf8_pieces ? "♚" : "k");
708 empty_wchar = str_to_wchar (" ");
709 enpassant_wchar = str_to_wchar ("x");
710 }
711
712 static wchar_t *
713 piece_to_wchar (unsigned char p)
714 {
715 switch (p)
716 {
717 case 'P':
718 return w_pawn_wchar;
719 case 'p':
720 return b_pawn_wchar;
721 case 'R':
722 return w_rook_wchar;
723 case 'r':
724 return b_rook_wchar;
725 case 'B':
726 return w_bishop_wchar;
727 case 'b':
728 return b_bishop_wchar;
729 case 'N':
730 return w_knight_wchar;
731 case 'n':
732 return b_knight_wchar;
733 case 'Q':
734 return w_queen_wchar;
735 case 'q':
736 return b_queen_wchar;
737 case 'K':
738 return w_king_wchar;
739 case 'k':
740 return b_king_wchar;
741 case 'x':
742 return enpassant_wchar;
743 }
744
745 return empty_wchar;
746 }
747
748 static int piece_can_attack (GAME g, int rank, int file)
749 {
750 struct userdata_s *d = g->data;
751 char *m, *frfr = NULL;
752 pgn_error_t e;
753 int row, col, p;
754 int v = d->b[RANKTOBOARD (d->c_row)][FILETOBOARD (d->c_col)].valid;
755 int pi = pgn_piece_to_int (d->b[RANKTOBOARD (rank)][FILETOBOARD (file)].icon);
756 int cpi = d->sp.icon
757 ? pgn_piece_to_int (d->b[RANKTOBOARD (d->sp.srow)][FILETOBOARD (d->sp.scol)].icon)
758 : pgn_piece_to_int (d->b[RANKTOBOARD (d->c_row)][FILETOBOARD (d->c_col)].icon);
759
760 if (pi == OPEN_SQUARE || cpi == OPEN_SQUARE || !VALIDFILE (file)
761 || !VALIDRANK (rank))
762 return 0;
763
764 if (d->sp.icon) {
765 col = v ? d->c_col : d->sp.scol;
766 row = v ? d->c_row : d->sp.srow;
767 }
768 else {
769 col = d->c_col;
770 row = d->c_row;
771 }
772
773 m = malloc(MAX_SAN_MOVE_LEN+1);
774 m[0] = INTTOFILE (file);
775 m[1] = INTTORANK (rank);
776 m[2] = INTTOFILE (col);
777 m[3] = INTTORANK (row);
778 m[4] = 0;
779
780 if (d->sp.icon && v) {
781 BOARD b;
782
783 memcpy (b, d->b, sizeof(BOARD));
784 p = b[RANKTOBOARD (d->sp.srow)][FILETOBOARD (d->sp.scol)].icon;
785 b[RANKTOBOARD (d->sp.srow)][FILETOBOARD (d->sp.scol)].icon =
786 pgn_int_to_piece (WHITE, OPEN_SQUARE);
787 b[RANKTOBOARD (row)][FILETOBOARD (col)].icon = p;
788 pgn_switch_turn(g);
789 e = pgn_validate_move (g, b, &m, &frfr);
790 pgn_switch_turn (g);
791 free (m);
792 free (frfr);
793 return e == E_PGN_OK ? 1 : 0;
794 }
795
796 pgn_switch_turn(g);
797 e = pgn_validate_move (g, d->b, &m, &frfr);
798 pgn_switch_turn (g);
799
800 if (!strcmp (m, "O-O") || !strcmp (m, "O-O-O"))
801 e = E_PGN_INVALID;
802
803 if (e == E_PGN_OK) {
804 int sf = FILETOINT (frfr[0]), sr = RANKTOINT (frfr[1]);
805 int df = FILETOINT (frfr[2]);
806
807 pi = d->b[RANKTOBOARD (sr)][FILETOBOARD (sf)].icon;
808 pi = pgn_piece_to_int (pi);
809 if (pi == PAWN && sf == df)
810 e = E_PGN_INVALID;
811 }
812
813 free (m);
814 free (frfr);
815 return e == E_PGN_OK ? 1 : 0;
816 }
817
818 void print_piece(WINDOW *w, int l, int c, char p)
819 {
820 int i, y, ff = 0;
821
822 for (i = 0; i < 13; i += 2) {
823 if (p == piece_chars[i] || p == piece_chars[i + 1]) {
824 for (y = 0; y < 3; y++)
825 mvwprintw(w, l + y, c, "%s", f_pieces[i + ff + y]);
826 return;
827 }
828
829 ff++;
830 }
831
832 for (y = 0; y < 3; y++)
833 mvwprintw(w, l + y, c, f_pieces[0]);
834 }
835
836 int inv_int(int x)
837 {
838 int fx, fx2 = 8;
839
840 for (fx = 1; fx < 9; fx++) {
841 if (x == fx)
842 break;
843 fx2--;
844 }
845
846 return fx2;
847 }
848
849 int coordofmove(char *move, int yorx)
850 {
851 int l, i;
852
853 if (!rotate) {
854 if (!strcmp(move, "O-O"))
855 return (yorx) ? 8 : 7;
856 else if (!strcmp(move, "O-O-O"))
857 return (yorx) ? 8 : 3;
858 }
859 else {
860 if (!strcmp(move, "O-O"))
861 return (yorx) ? 1 : 7;
862 else if (!strcmp(move, "O-O-O"))
863 return (yorx) ? 1 : 3;
864 }
865
866 l = strlen(move);
867
868 if (yorx)
869 return move[l - 1] - 48;
870 else {
871 for (i = 0; i < 8; i++) {
872 if (move[l - 2] == "abcdefgh"[i])
873 return i + 1;
874 }
875 }
876
877 return 0;
878 }
879
880 static int is_prev_move (struct userdata_s *d, int brow, int bcol,
881 int row, int col)
882 {
883 if ((!BIG_BOARD &&
884 row == ROWTOMATRIX(((rotate) ? inv_int(d->pm_row) : d->pm_row)) &&
885 col == COLTOMATRIX(((rotate) ? inv_int(d->pm_col) : d->pm_col)))
886 || (BIG_BOARD &&
887 brow + 1 == ((rotate) ? d->pm_row : inv_int(d->pm_row)) &&
888 bcol + 1 == ((rotate) ? inv_int(d->pm_col) : d->pm_col)))
889 return 1;
890
891 return 0;
892 }
893
894 // FIXME: BIG_BOARD - start in dwm monocle layout.
895 // Example: lxterminal -e cboard (dmenu, geany, etc.)
896 void update_board_window(GAME g)
897 {
898 int row, col;
899 int bcol = 0, brow = 0;
900 int l = config.coordsyleft;
901 int maxy = BOARD_HEIGHT, maxx = BOARD_WIDTH;
902 int ncols = 0, offset = 1;
903 int rowr = (MEGA_BOARD) ? 6 : (BIG_BOARD) ? 4 : 2;
904 int colr = (MEGA_BOARD) ? 12 : (BIG_BOARD) ? 8 : 4;
905 unsigned coords_y = 8, cxgc = 0;
906 unsigned i, cpd = 0;
907 struct userdata_s *d = g->data;
908 HISTORY *h = NULL;
909
910 h = pgn_history_by_n(g->hp, g->hindex - 1);
911 d->pm_row = (h && h->move && d->mode == MODE_PLAY)
912 ? coordofmove(h->move, 1) : 0;
913 d->pm_col = (h && h->move && d->mode == MODE_PLAY)
914 ? coordofmove(h->move, 0) : 0;
915
916 if (d->mode != MODE_PLAY && d->mode != MODE_EDIT)
917 update_cursor(g, g->hindex);
918
919 if (BIG_BOARD) {
920 if (rotate) {
921 brow = 7;
922 coords_y = 1;
923 }
924 }
925 else {
926 if (rotate) {
927 brow = 1;
928 coords_y = 1;
929 }
930 else
931 brow = 8;
932 }
933
934 for (row = 0; row < maxy; row++) {
935 if (BIG_BOARD) {
936 if (rotate)
937 bcol = 7;
938 else
939 bcol = 0;
940 }
941 else {
942 if (rotate)
943 bcol = 8;
944 else
945 bcol = 1;
946 }
947
948 for (col = 0; col < maxx; col++) {
949 int attrwhich = -1;
950 chtype attrs = 0, old_attrs = 0;
951 unsigned char p;
952 int can_attack = 0;
953 int valid = 0;
954
955 if (row == 0 || row == maxy - 2) {
956 if (col == 0)
957 mvwaddch(boardw, row, col + l,
958 LINE_GRAPHIC((row)
959 ? ACS_LLCORNER | CP_BOARD_GRAPHICS
960 : ACS_ULCORNER | CP_BOARD_GRAPHICS));
961 else if (col == maxx - 2)
962 mvwaddch(boardw, row, col + l,
963 LINE_GRAPHIC((row)
964 ? ACS_LRCORNER | CP_BOARD_GRAPHICS
965 : ACS_URCORNER | CP_BOARD_GRAPHICS));
966 else if (!(col % colr))
967 mvwaddch(boardw, row, col + l,
968 LINE_GRAPHIC((row)
969 ? ACS_BTEE | CP_BOARD_GRAPHICS
970 : ACS_TTEE | CP_BOARD_GRAPHICS));
971 else {
972 if (col != maxx - 1)
973 mvwaddch(boardw, row, col + l,
974 LINE_GRAPHIC(ACS_HLINE | CP_BOARD_GRAPHICS));
975 }
976
977 continue;
978 }
979
980 if ((row % 2) && col == maxx - 1 &&
981 (coords_y > 0 && coords_y < 9)) {
982 wattron(boardw, CP_BOARD_COORDS);
983 mvwprintw(boardw,
984 (BIG_BOARD) ? row * ((MEGA_BOARD) ? 3 : 2)
985 : row, (l) ? 0 : col, "%d",
986 (rotate) ? coords_y++ : coords_y--);
987 wattroff(boardw, CP_BOARD_COORDS);
988 continue;
989 }
990
991 if ((col == 0 || col == maxx - 2) && row != maxy - 1) {
992 if (!(row % rowr))
993 mvwaddch(boardw, row, col + l,
994 LINE_GRAPHIC((col) ?
995 ACS_RTEE | CP_BOARD_GRAPHICS :
996 ACS_LTEE | CP_BOARD_GRAPHICS));
997 else
998 mvwaddch(boardw, row, col + l,
999 LINE_GRAPHIC(ACS_VLINE | CP_BOARD_GRAPHICS));
1000
1001 continue;
1002 }
1003
1004 if ((row % rowr) && !(col % colr) && row != maxy - 1) {
1005 mvwaddch(boardw, row, col + l,
1006 LINE_GRAPHIC(ACS_VLINE | CP_BOARD_GRAPHICS));
1007 continue;
1008 }
1009
1010 if (!(col % colr) && row != maxy - 1) {
1011 mvwaddch(boardw, row, col + l,
1012 LINE_GRAPHIC(ACS_PLUS | CP_BOARD_GRAPHICS));
1013 continue;
1014 }
1015
1016 if ((row % rowr)) {
1017 if ((col % colr)) {
1018 if (BIG_BOARD)
1019 attrwhich = (cb[brow][bcol]) ? WHITE : BLACK;
1020 else {
1021 if (ncols++ == 8) {
1022 offset++;
1023 ncols = 1;
1024 }
1025
1026 if (((ncols % 2) && !(offset % 2))
1027 || (!(ncols % 2) && (offset % 2)))
1028 attrwhich = BLACK;
1029 else
1030 attrwhich = WHITE;
1031 }
1032
1033 if (BIG_BOARD && rotate) {
1034 brow = inv_int(brow + 1) - 1;
1035 bcol = inv_int(bcol + 1) - 1;
1036 }
1037
1038 if (BIG_BOARD)
1039 p = d->b[brow][bcol].icon;
1040 else
1041 p = d->b[RANKTOBOARD (brow)][FILETOBOARD (bcol)].icon;
1042
1043 int pi = pgn_piece_to_int(p);
1044
1045 if (config.details &&
1046 ((!BIG_BOARD && d->b[RANKTOBOARD (brow)][FILETOBOARD (bcol)].enpassant)
1047 || (BIG_BOARD && d->b[brow][bcol].enpassant))) {
1048 p = pi = 'x';
1049 attrs = mix_cp(CP_BOARD_ENPASSANT,
1050 (attrwhich == WHITE) ? CP_BOARD_WHITE : CP_BOARD_BLACK,
1051 ATTRS(CP_BOARD_ENPASSANT), A_FG_B_BG);
1052 }
1053
1054 // FIXME: showattacks - rotated board.
1055 if (config.showattacks && config.details
1056 && piece_can_attack (g,
1057 BIG_BOARD ? inv_int (brow+1) : brow,
1058 BIG_BOARD ? bcol+1 : bcol)) {
1059 attrs = CP_BOARD_ATTACK;
1060 old_attrs = attrs;
1061 can_attack = 1;
1062 }
1063
1064 if (config.validmoves &&
1065 ((!BIG_BOARD && d->b[RANKTOBOARD (brow)][FILETOBOARD (bcol)].valid)
1066 || (BIG_BOARD && d->b[brow][bcol].valid))) {
1067 old_attrs = -1;
1068 valid = 1;
1069
1070 if (attrwhich == WHITE)
1071 attrs = mix_cp(CP_BOARD_MOVES_WHITE,
1072 IS_ENPASSANT(p),
1073 ATTRS(CP_BOARD_MOVES_WHITE),
1074 B_FG_A_BG);
1075 else
1076 attrs = mix_cp(CP_BOARD_MOVES_BLACK,
1077 IS_ENPASSANT(p),
1078 ATTRS(CP_BOARD_MOVES_BLACK),
1079 B_FG_A_BG);
1080 }
1081 else if (p != 'x' && !can_attack)
1082 attrs = (attrwhich == WHITE) ? CP_BOARD_WHITE : CP_BOARD_BLACK;
1083
1084 if (BIG_BOARD && rotate) {
1085 brow = inv_int(brow + 1) - 1;
1086 bcol = inv_int(bcol + 1) - 1;
1087 }
1088
1089 if ((!BIG_BOARD && row == ROWTOMATRIX(d->c_row)
1090 && col == COLTOMATRIX(d->c_col))
1091 || (BIG_BOARD && brow + 1 == inv_int(d->c_row)
1092 && bcol + 1 == d->c_col)) {
1093 attrs = mix_cp(CP_BOARD_CURSOR, IS_ENPASSANT(p),
1094 ATTRS(CP_BOARD_CURSOR), B_FG_A_BG);
1095 old_attrs = -1;
1096 }
1097 else if ((!BIG_BOARD && row == ROWTOMATRIX(d->sp.srow) &&
1098 col == COLTOMATRIX(d->sp.scol)) ||
1099 (BIG_BOARD && brow + 1 == inv_int(d->sp.srow) &&
1100 bcol + 1 == d->sp.scol)) {
1101 attrs = mix_cp(CP_BOARD_SELECTED, IS_ENPASSANT(p),
1102 ATTRS(CP_BOARD_SELECTED), B_FG_A_BG);
1103 old_attrs = -1;
1104 }
1105 else if (is_prev_move (d, brow, bcol, row, col) && !valid)
1106 {
1107 attrs = mix_cp(CP_BOARD_PREVMOVE, IS_ENPASSANT(p),
1108 ATTRS(CP_BOARD_PREVMOVE), B_FG_A_BG);
1109 old_attrs = -1;
1110 }
1111
1112 if (row == maxy - 1)
1113 attrs = 0;
1114
1115 if (can_attack) {
1116 int n = is_prev_move (d, brow, bcol, row, col);
1117 chtype a = n && !valid
1118 ? CP_BOARD_PREVMOVE : attrwhich == WHITE ? valid ? CP_BOARD_MOVES_WHITE : CP_BOARD_WHITE : valid ? CP_BOARD_MOVES_BLACK : CP_BOARD_BLACK;
1119 attrs = mix_cp(CP_BOARD_ATTACK, a,
1120 ATTRS (CP_BOARD_ATTACK), A_FG_B_BG);
1121 old_attrs = -1;
1122 }
1123
1124 if (BIG_BOARD)
1125 wmove(boardw, row, col + ((MEGA_BOARD) ? 5 : 3) + l);
1126 else
1127 mvwaddch(boardw, row, col + l, ' ' | attrs);
1128
1129 if (row == maxy - 1 && cxgc < 8) {
1130 waddch(boardw, "abcdefgh"[(BIG_BOARD) ? bcol : bcol - 1] | CP_BOARD_COORDS);
1131 cxgc++;
1132 }
1133 else {
1134 if (old_attrs == -1) {
1135 old_attrs = attrs;
1136 goto printc;
1137 }
1138
1139 old_attrs = attrs;
1140
1141 if (pi != OPEN_SQUARE && p != 'x' && !can_attack) {
1142 if (attrwhich == WHITE) {
1143 if (isupper(p))
1144 attrs = CP_BOARD_W_W;
1145 else
1146 attrs = CP_BOARD_W_B;
1147 }
1148 else {
1149 if (isupper(p))
1150 attrs = CP_BOARD_B_W;
1151 else
1152 attrs = CP_BOARD_B_B;
1153 }
1154 }
1155
1156 printc:
1157 if (BIG_BOARD) {
1158 if (config.details && !can_attack
1159 && castling_state(g, d->b,
1160 (rotate) ? inv_int(brow + 1) - 1: brow,
1161 (rotate) ? inv_int(bcol + 1) - 1: bcol, p, 0))
1162 attrs = mix_cp(CP_BOARD_CASTLING, attrs,
1163 ATTRS(CP_BOARD_CASTLING),
1164 A_FG_B_BG);
1165 }
1166 else {
1167 if (config.details && !can_attack
1168 && castling_state(g, d->b, RANKTOBOARD (brow),
1169 FILETOBOARD (bcol), p, 0)) {
1170 attrs = mix_cp(CP_BOARD_CASTLING, attrs,
1171 ATTRS(CP_BOARD_CASTLING),
1172 A_FG_B_BG);
1173 }
1174 }
1175
1176 if (BIG_BOARD) {
1177 // FIXME: Reimpresión de piezas(+3).
1178 if (cpd < 67) {
1179 wattron (boardw, attrs);
1180 if (MEGA_BOARD){
1181 for (i = 0; i < 5; i++)
1182 mvwprintw(boardw, i + brow * 6 + 1,
1183 bcol * 12 + 1 + l,
1184 " ");
1185 if (pi != OPEN_SQUARE)
1186 print_piece(boardw, brow * 6 + 2,
1187 bcol * 12 + 3 + l, p);
1188 }
1189 else {
1190 print_piece(boardw, brow * 4 + 1,
1191 bcol * 8 + 1 + l,
1192 (pi != OPEN_SQUARE) ? p : 0);
1193 }
1194
1195 wattroff (boardw, attrs);
1196 cpd++;
1197 }
1198 }
1199 else {
1200 wattron (boardw, attrs);
1201 waddwstr (boardw, piece_to_wchar (pi != OPEN_SQUARE ? p : 0));
1202 wattroff (boardw, attrs);
1203 }
1204
1205 attrs = old_attrs;
1206 }
1207
1208 if (BIG_BOARD)
1209 col += (MEGA_BOARD) ? 10 : 6;
1210 else {
1211 waddch(boardw, ' ' | attrs);
1212 col += 2;
1213 }
1214
1215 if (rotate)
1216 bcol--;
1217 else
1218 bcol++;
1219
1220 if (BIG_BOARD) {
1221 if (bcol > 7)
1222 bcol = 0;
1223 if (bcol < 0)
1224 bcol = 7;
1225 }
1226 }
1227 }
1228 else {
1229 if (col != maxx - 1)
1230 mvwaddch(boardw, row, col + l,
1231 LINE_GRAPHIC(ACS_HLINE | CP_BOARD_GRAPHICS));
1232 }
1233 }
1234
1235 if (row % rowr) {
1236 if (rotate)
1237 brow++;
1238 else
1239 brow--;
1240 }
1241
1242 if (BIG_BOARD) {
1243 if (brow > 7)
1244 brow = 0;
1245 if (brow < 0)
1246 brow = 7;
1247 }
1248 }
1249 }
1250
1251 void invalid_move(int n, int e, const char *m)
1252 {
1253 if (curses_initialized)
1254 cmessage(ERROR_STR, ANY_KEY_STR, "%s \"%s\" (round #%i)", (e == E_PGN_AMBIGUOUS)
1255 ? _("Ambiguous move") : _("Invalid move"), m, n);
1256 else
1257 warnx("%s: %s \"%s\" (round #%i)", loadfile, (e == E_PGN_AMBIGUOUS)
1258 ? _("Ambiguous move") : _("Invalid move"), m, n);
1259 }
1260
1261 void gameover(GAME g)
1262 {
1263 struct userdata_s *d = g->data;
1264
1265 SET_FLAG(g->flags, GF_GAMEOVER);
1266 d->mode = MODE_HISTORY;
1267 stop_engine(g);
1268 }
1269
1270 static void update_clock(GAME g, struct itimerval it)
1271 {
1272 struct userdata_s *d = g->data;
1273
1274 if (TEST_FLAG(d->flags, CF_CLOCK) && g->turn == WHITE) {
1275 d->wclock.elapsed.tv_sec += it.it_value.tv_sec;
1276 d->wclock.elapsed.tv_usec += it.it_value.tv_usec;
1277
1278 if (d->wclock.elapsed.tv_usec > 1000000 - 1) {
1279 d->wclock.elapsed.tv_sec += d->wclock.elapsed.tv_usec / 1000000;
1280 d->wclock.elapsed.tv_usec = d->wclock.elapsed.tv_usec % 1000000;
1281 }
1282
1283 if (d->wclock.tc[d->wclock.tcn][1] &&
1284 d->wclock.elapsed.tv_sec >= d->wclock.tc[d->wclock.tcn][1]) {
1285 pgn_tag_add(&g->tag, "Result", "0-1");
1286 gameover(g);
1287 }
1288 }
1289 else if (TEST_FLAG(d->flags, CF_CLOCK) && g->turn == BLACK) {
1290 d->bclock.elapsed.tv_sec += it.it_value.tv_sec;
1291 d->bclock.elapsed.tv_usec += it.it_value.tv_usec;
1292
1293 if (d->bclock.elapsed.tv_usec > 1000000 - 1) {
1294 d->bclock.elapsed.tv_sec += d->bclock.elapsed.tv_usec / 1000000;
1295 d->bclock.elapsed.tv_usec = d->bclock.elapsed.tv_usec % 1000000;
1296 }
1297
1298 if (d->bclock.tc[d->bclock.tcn][1] &&
1299 d->bclock.elapsed.tv_sec >= d->bclock.tc[d->bclock.tcn][1]) {
1300 pgn_tag_add(&g->tag, "Result", "1-0");
1301 gameover(g);
1302 }
1303 }
1304
1305 d->elapsed.tv_sec += it.it_value.tv_sec;
1306 d->elapsed.tv_usec += it.it_value.tv_usec;
1307
1308 if (d->elapsed.tv_usec > 1000000 - 1) {
1309 d->elapsed.tv_sec += d->elapsed.tv_usec / 1000000;
1310 d->elapsed.tv_usec = d->elapsed.tv_usec % 1000000;
1311 }
1312 }
1313
1314 static void update_time_control(GAME g)
1315 {
1316 struct userdata_s *d = g->data;
1317 struct clock_s *clk = (g->turn == WHITE) ? &d->wclock : &d->bclock;
1318
1319 if (clk->incr)
1320 clk->tc[clk->tcn][1] += clk->incr;
1321
1322 if (!clk->tc[clk->tcn][1])
1323 return;
1324
1325 clk->move++;
1326
1327 if (!clk->tc[clk->tcn][0] || clk->move >= clk->tc[clk->tcn][0]) {
1328 clk->move = 0;
1329 clk->tc[clk->tcn + 1][1] += abs(clk->elapsed.tv_sec - clk->tc[clk->tcn][1]);
1330 memset(&clk->elapsed, 0, sizeof(clk->elapsed));
1331 clk->tcn++;
1332 }
1333 }
1334
1335 void update_history_window(GAME g)
1336 {
1337 char buf[HISTORY_WIDTH - 1];
1338 HISTORY *h = NULL;
1339 int n, total;
1340 int t = pgn_history_total(g->hp);
1341
1342 n = (g->hindex + 1) / 2;
1343
1344 if (t % 2)
1345 total = (t + 1) / 2;
1346 else
1347 total = t / 2;
1348
1349 if (t)
1350 snprintf(buf, sizeof(buf), "%u %s %u%s", n, _("of"), total,
1351 (movestep == 1) ? _(" (ply)") : "");
1352 else
1353 strncpy(buf, _("not available"), sizeof(buf)-1);
1354
1355 buf[sizeof(buf)-1] = 0;
1356 mvwprintw(historyw, 2, 1, "%*s %-*s", 10, _("Move:"),
1357 HISTORY_WIDTH - 14, buf);
1358
1359 h = pgn_history_by_n(g->hp, g->hindex);
1360 snprintf(buf, sizeof(buf), "%s",
1361 (h && h->move) ? h->move
1362 : (LINES < 24) ? _("empty") : _("not available"));
1363 n = 0;
1364
1365 if (h && ((h->comment) || h->nag[0])) {
1366 strncat(buf, _(" (Annotated"), sizeof(buf)-1);
1367 n++;
1368 }
1369
1370 if (h && h->rav) {
1371 strncat(buf, (n) ? ",+" : " (+", sizeof(buf)-1);
1372 n++;
1373 }
1374
1375 if (g->ravlevel) {
1376 strncat(buf, (n) ? ",-" : " (-", sizeof(buf)-1);
1377 n++;
1378 }
1379
1380 if (n)
1381 strncat(buf, ")", sizeof(buf)-1);
1382
1383 mvwprintw(historyw, 3, ((LINES < 24) ? 17 : 1), "%s %-*s",
1384 (LINES < 24) ? _("Next:") :_("Next move:"),
1385 HISTORY_WIDTH - ((LINES < 24) ? 26 : 14), buf);
1386
1387 h = pgn_history_by_n(g->hp, g->hindex - 1);
1388 snprintf(buf, sizeof(buf), "%s",
1389 (h && h->move) ? h->move
1390 : (LINES < 24) ? _("empty") : _("not available"));
1391 n = 0;
1392
1393 if (h && ((h->comment) || h->nag[0])) {
1394 strncat(buf, _(" (Annotated"), sizeof(buf)-1);
1395 n++;
1396 }
1397
1398 if (h && h->rav) {
1399 strncat(buf, (n) ? ",+" : " (+", sizeof(buf)-1);
1400 n++;
1401 }
1402
1403 if (g->ravlevel) {
1404 strncat(buf, (n) ? ",-" : " (-", sizeof(buf)-1);
1405 n++;
1406 }
1407
1408 if (n)
1409 strncat(buf, ")", sizeof(buf)-1);
1410
1411 mvwprintw(historyw, ((LINES < 24) ? 3 : 4), 1, "%s %-*s",
1412 (LINES < 24) ? _("Prev.:") : _("Prev move:"),
1413 HISTORY_WIDTH - ((LINES < 24) ? 26 : 14), buf);
1414 }
1415
1416 void do_validate_move(char *move)
1417 {
1418 struct userdata_s *d = gp->data;
1419 int n;
1420 char *frfr = NULL;
1421
1422 if (TEST_FLAG(d->flags, CF_HUMAN)) {
1423 if ((n = pgn_parse_move(gp, d->b, &move, &frfr)) != E_PGN_OK) {
1424 invalid_move(d->n + 1, n, move);
1425 return;
1426 }
1427
1428 update_time_control(gp);
1429 pgn_history_add(gp, d->b, move);
1430 pgn_switch_turn(gp);
1431 }
1432 else {
1433 if ((n = pgn_validate_move(gp, d->b, &move, &frfr)) != E_PGN_OK) {
1434 invalid_move(d->n + 1, n, move);
1435 return;
1436 }
1437
1438 add_engine_command(gp, ENGINE_THINKING, "%s\n",
1439 (config.engine_protocol == 1) ? frfr : move);
1440 }
1441
1442 d->sp.srow = d->sp.scol = d->sp.icon = 0;
1443
1444 if (config.validmoves)
1445 pgn_reset_valid_moves(d->b);
1446
1447 if (TEST_FLAG(gp->flags, GF_GAMEOVER))
1448 d->mode = MODE_HISTORY;
1449 else
1450 SET_FLAG(d->flags, CF_MODIFIED);
1451
1452 free (frfr);
1453 d->paused = 0;
1454 update_history_window(gp);
1455 update_board_window(gp);
1456 return;
1457 }
1458
1459 void do_promotion_piece_finalize(WIN *win)
1460 {
1461 char *p, *str = win->data;
1462
1463 if (pgn_piece_to_int(win->c) == -1)
1464 return;
1465
1466 p = str + strlen(str);
1467 *p++ = toupper(win->c);
1468 *p = '\0';
1469 do_validate_move(str);
1470 free (win->data);
1471 win->data = NULL;
1472 }
1473
1474 static void move_to_engine(GAME g)
1475 {
1476 struct userdata_s *d = g->data;
1477 char *str;
1478 int piece;
1479
1480 if (config.validmoves &&
1481 !d->b[RANKTOBOARD(d->sp.row)][FILETOBOARD(d->sp.col)].valid)
1482 return;
1483
1484 str = Malloc(MAX_SAN_MOVE_LEN + 1);
1485 snprintf(str, MAX_SAN_MOVE_LEN + 1, "%c%i%c%i",
1486 _("abcdefgh")[d->sp.scol - 1],
1487 d->sp.srow, _("abcdefgh")[d->sp.col - 1], d->sp.row);
1488
1489 piece = pgn_piece_to_int(d->b[RANKTOBOARD(d->sp.srow)][FILETOBOARD(d->sp.scol)].icon);
1490
1491 if (piece == PAWN && (d->sp.row == 8 || d->sp.row == 1)) {
1492 construct_message(_("Select Pawn Promotion Piece"), _ ("R/N/B/Q"), 1, 1, NULL, NULL,
1493 str, do_promotion_piece_finalize, 0, 0, "%s", _("R = Rook, N = Knight, B = Bishop, Q = Queen"));
1494 return;
1495 }
1496
1497 do_validate_move(str);
1498 free (str);
1499 }
1500
1501 static char *clock_to_char(long n)
1502 {
1503 static char buf[16];
1504 int h = 0, m = 0, s = 0;
1505
1506 h = n / 3600;
1507 m = (n % 3600) / 60;
1508 s = (n % 3600) % 60;
1509 snprintf(buf, sizeof(buf), "%.2i:%.2i:%.2i", h, m, s);
1510 return buf;
1511 }
1512
1513 static char *timeval_to_char(struct timeval t, long limit)
1514 {
1515 static char buf[9];
1516 int h = 0, m = 0, s = 0;
1517 int n = limit ? abs(limit - t.tv_sec) : 0;
1518
1519 h = n / 3600;
1520 m = (n % 3600) / 60;
1521 s = (n % 3600) % 60;
1522 snprintf(buf, sizeof(buf), "%.2i:%.2i:%.2i", h, m, s);
1523 return buf;
1524 }
1525
1526 static char *time_control_status(struct clock_s *clk)
1527 {
1528 static char buf[80] = {0};
1529
1530 buf[0] = 0;
1531
1532 if (clk->tc[clk->tcn][0] && clk->tc[clk->tcn + 1][1])
1533 snprintf(buf, sizeof(buf), " M%.2i/%s", abs(clk->tc[clk->tcn][0] - clk->move),
1534 clock_to_char(clk->tc[clk->tcn + 1][1]));
1535 else if (!clk->incr)
1536 return "";
1537
1538 if (clk->incr) {
1539 char buf[16];
1540 strncat(buf, " I", sizeof(buf)-1);
1541 strncat(buf, itoa(clk->incr, buf), sizeof(buf)-1);
1542 }
1543
1544 return buf;
1545 }
1546
1547 void update_status_window(GAME g)
1548 {
1549 int i = 0;
1550 char *buf;
1551 char tmp[15] = {0}, *engine, *mode;
1552 char t[COLS];
1553 int w;
1554 char *p;
1555 int maxy, maxx;
1556 int len;
1557 struct userdata_s *d = g->data;
1558 int y;
1559 int n;
1560
1561 if (!curses_initialized)
1562 return;
1563
1564 getmaxyx(statusw, maxy, maxx);
1565 (void)maxy;
1566 w = maxx - 2 - 8;
1567 len = maxx - 2;
1568 buf = Malloc(len);
1569 y = 2;
1570
1571 wchar_t *loadfilew = loadfile[0] ? str_etc (loadfile, w, 1) : str_to_wchar (_ ("not available"));
1572 mvwprintw(statusw, y++, 1, "%*s %-*ls", 7, _("File:"), w, loadfilew);
1573 free (loadfilew);
1574 snprintf(buf, len, "%i %s %i", gindex + 1, _("of"), gtotal);
1575 mvwprintw(statusw, y++, 1, "%*s %-*s", 7, _("Game:"), w, buf);
1576
1577 *tmp = '\0';
1578 p = tmp;
1579
1580 if (config.details) {
1581 *p++ = 'D';
1582 i++;
1583 }
1584
1585 if (TEST_FLAG(d->flags, CF_DELETE)) {
1586 if (i)
1587 *p++ = '/';
1588
1589 *p++ = 'X';
1590 i++;
1591 }
1592
1593 if (TEST_FLAG(g->flags, GF_PERROR)) {
1594 if (i)
1595 *p++ = '/';
1596
1597 *p++ = '!';
1598 i++;
1599 }
1600
1601 if (TEST_FLAG(d->flags, CF_MODIFIED)) {
1602 if (i)
1603 *p++ = '/';
1604
1605 *p++ = '*';
1606 i++;
1607 }
1608
1609 pgn_config_get(PGN_STRICT_CASTLING, &n);
1610
1611 if (n == 1) {
1612 if (i)
1613 *p++ = '/';
1614
1615 *p++ = 'C';
1616 i++;
1617 }
1618 #ifdef WITH_LIBPERL
1619 if (TEST_FLAG(d->flags, CF_PERL)) {
1620 if (i)
1621 *p++ = '/';
1622
1623 *p++ = 'P';
1624 i++;
1625 }
1626 #endif
1627
1628 *p = '\0';
1629 mvwprintw(statusw, y++, 1, "%*s %-*s", 7, _("Flags:"), w, (tmp[0]) ? tmp : "-");
1630
1631 switch (d->mode) {
1632 case MODE_HISTORY:
1633 mode = _("move history");
1634 break;
1635 case MODE_EDIT:
1636 mode = _("edit");
1637 break;
1638 case MODE_PLAY:
1639 mode = _("play");
1640 break;
1641 default:
1642 mode = _("(empty value)");
1643 break;
1644 }
1645
1646 snprintf(buf, len - 1, "%*s %s", 7, _("Mode:"), mode);
1647
1648 if (d->mode == MODE_PLAY) {
1649 if (TEST_FLAG(d->flags, CF_HUMAN))
1650 strncat(buf, _(" (human/human)"), len - 1);
1651 else if (TEST_FLAG(d->flags, CF_ENGINE_LOOP))
1652 strncat(buf, _(" (engine/engine)"), len - 1);
1653 else
1654 strncat(buf, (d->play_mode == PLAY_EH) ?
1655 _(" (engine/human)") : _(" (human/engine)"), len - 1);
1656 }
1657
1658 buf[len-1] = 0;
1659 mvwprintw(statusw, y++, 1, "%-*s", len, buf);
1660 free(buf);
1661
1662 if (d->engine) {
1663 switch (d->engine->status) {
1664 case ENGINE_THINKING:
1665 engine = _("pondering...");
1666 break;
1667 case ENGINE_READY:
1668 engine = _("ready");
1669 break;
1670 case ENGINE_INITIALIZING:
1671 engine = _("initializing...");
1672 break;
1673 case ENGINE_OFFLINE:
1674 engine = _("offline");
1675 break;
1676 default:
1677 engine = _("(empty value)");
1678 break;
1679 }
1680 }
1681 else
1682 engine = _("offline");
1683
1684 mvwprintw(statusw, y, 1, "%*s %-*s", 7, _("Engine:"), w, " ");
1685 wattron(statusw, CP_STATUS_ENGINE);
1686 mvwaddstr(statusw, y++, 9, engine);
1687 wattroff(statusw, CP_STATUS_ENGINE);
1688
1689 mvwprintw(statusw, y++, 1, "%*s %-*s", 7, _("Turn:"), w,
1690 (g->turn == WHITE) ? _("white") : _("black"));
1691
1692 strncpy(tmp, _("white"), sizeof(tmp)-1);
1693 tmp[0] = toupper(tmp[0]);
1694 snprintf(t, sizeof(t), "%s%s",
1695 timeval_to_char(d->wclock.elapsed, d->wclock.tc[d->wclock.tcn][1]),
1696 time_control_status(&d->wclock));
1697 mvwprintw(statusw, y++, 1, "%*s: %-*s", 6, tmp, w, t);
1698
1699 strncpy(tmp, _("black"), sizeof(tmp)-1);
1700 tmp[0] = toupper(tmp[0]);
1701 snprintf(t, sizeof(t), "%s%s",
1702 timeval_to_char(d->bclock.elapsed, d->bclock.tc[d->bclock.tcn][1]),
1703 time_control_status(&d->bclock));
1704 mvwprintw(statusw, y++, 1, "%*s: %-*s", 6, tmp, w, t);
1705
1706 mvwprintw(statusw, y++, 1, "%*s %-*s", 7, _("Total:"), w,
1707 clock_to_char(d->elapsed.tv_sec));
1708
1709 // for (i = 0; i < STATUS_WIDTH; i++)
1710 // mvwprintw(stdscr, STATUS_HEIGHT, i, " ");
1711
1712 if (!status.notify)
1713 status.notify = str_to_wchar(_("Type F1 for help"));
1714
1715 wattron(stdscr, CP_STATUS_NOTIFY);
1716 for (i = (config.boardleft) ? BOARD_WIDTH : 0;
1717 i < ((config.boardleft) ? COLS : STATUS_WIDTH); i++)
1718 mvwprintw(stdscr, STATUS_HEIGHT, i, " ");
1719 mvwprintw(stdscr, STATUS_HEIGHT, CENTERX(STATUS_WIDTH, status.notify)
1720 + ((config.boardleft) ? BOARD_WIDTH : 0),
1721 "%ls", status.notify);
1722 wattroff(stdscr, CP_STATUS_NOTIFY);
1723 }
1724
1725 wchar_t *translate_tag_name(const char *tag)
1726 {
1727 if (!strcmp (tag, "Event"))
1728 return str_to_wchar (translatable_tag_names[0]);
1729 else if (!strcmp (tag, "Site"))
1730 return str_to_wchar (translatable_tag_names[1]);
1731 else if (!strcmp (tag, "Date"))
1732 return str_to_wchar (translatable_tag_names[2]);
1733 else if (!strcmp (tag, "Round"))
1734 return str_to_wchar (translatable_tag_names[3]);
1735 else if (!strcmp (tag, "White"))
1736 return str_to_wchar (translatable_tag_names[4]);
1737 else if (!strcmp (tag, "Black"))
1738 return str_to_wchar (translatable_tag_names[5]);
1739 else if (!strcmp (tag, "Result"))
1740 return str_to_wchar (translatable_tag_names[6]);
1741
1742 return str_to_wchar (tag);
1743 }
1744
1745 void update_tag_window(TAG **t)
1746 {
1747 int i, l, w;
1748 int namel = 0;
1749
1750 for (i = 0; t[i]; i++) {
1751 wchar_t *namewc = translate_tag_name(t[i]->name);
1752
1753 l = wcslen(namewc);
1754 free (namewc);
1755 if (l > namel)
1756 namel = l;
1757 }
1758
1759 w = TAG_WIDTH - namel - 4;
1760
1761 for (i = 0; t[i] && i < TAG_HEIGHT - 3; i++) {
1762 wchar_t *namewc = translate_tag_name(t[i]->name);
1763 wchar_t *valuewc = str_etc(t[i]->value, w, 0);
1764
1765 mvwprintw(tagw, (i + 2), 1, "%*ls: %-*ls", namel, namewc, w, valuewc);
1766 free (namewc);
1767 free (valuewc);
1768 }
1769
1770 for (; i < TAG_HEIGHT - 3; i++)
1771 mvwprintw(tagw, (i + 2), 1, "%*s", namel + w + 2, " ");
1772 }
1773
1774 void append_enginebuf(GAME g, char *line)
1775 {
1776 int i = 0;
1777 struct userdata_s *d = g->data;
1778
1779 if (d->engine->enginebuf)
1780 for (i = 0; d->engine->enginebuf[i]; i++);
1781
1782 if (i >= LINES - 3) {
1783 free(d->engine->enginebuf[0]);
1784
1785 for (i = 0; d->engine->enginebuf[i+1]; i++)
1786 d->engine->enginebuf[i] = d->engine->enginebuf[i+1];
1787
1788 d->engine->enginebuf[i] = strdup(line);
1789 }
1790 else {
1791 d->engine->enginebuf = Realloc(d->engine->enginebuf, (i + 2) * sizeof(char *));
1792 d->engine->enginebuf[i++] = strdup(line);
1793 d->engine->enginebuf[i] = NULL;
1794 }
1795 }
1796
1797 void update_engine_window(GAME g)
1798 {
1799 int i;
1800 struct userdata_s *d = g->data;
1801
1802 wmove(enginew, 0, 0);
1803 wclrtobot(enginew);
1804
1805 if (d->engine && d->engine->enginebuf) {
1806 for (i = 0; d->engine->enginebuf[i]; i++)
1807 mvwprintw(enginew, i + 2, 1, "%s", d->engine->enginebuf[i]);
1808 }
1809
1810 window_draw_title(enginew, _("Engine IO Window"), COLS, CP_MESSAGE_TITLE,
1811 CP_MESSAGE_BORDER);
1812 }
1813
1814 void update_all(GAME g)
1815 {
1816 struct userdata_s *d = g->data;
1817
1818 /*
1819 * In the middle of a macro. Don't update the screen.
1820 */
1821 if (macro_match != -1)
1822 return;
1823
1824 wmove(boardw, ROWTOMATRIX(d->c_row), COLTOMATRIX(d->c_col));
1825 update_board_window(g);
1826 update_status_window(g);
1827 update_history_window(g);
1828 update_tag_window(g->tag);
1829 update_engine_window(g);
1830 update_panels();
1831 doupdate();
1832 }
1833
1834 static void game_next_prev(GAME g, int n, int count)
1835 {
1836 if (gtotal < 2)
1837 return;
1838
1839 if (n == 1) {
1840 if (gindex + count > gtotal - 1) {
1841 if (count != 1)
1842 gindex = gtotal - 1;
1843 else
1844 gindex = 0;
1845 }
1846 else
1847 gindex += count;
1848 }
1849 else {
1850 if (gindex - count < 0) {
1851 if (count != 1)
1852 gindex = 0;
1853 else
1854 gindex = gtotal - 1;
1855 }
1856 else
1857 gindex -= count;
1858 }
1859
1860 gp = game[gindex];
1861 }
1862
1863 static void delete_game(int which)
1864 {
1865 GAME *g = NULL;
1866 int gi = 0;
1867 int i;
1868 struct userdata_s *d;
1869
1870 for (i = 0; i < gtotal; i++) {
1871 d = game[i]->data;
1872
1873 if (i == which || TEST_FLAG(d->flags, CF_DELETE)) {
1874 free_userdata_once(game[i]);
1875 pgn_free(game[i]);
1876 continue;
1877 }
1878
1879 g = Realloc(g, (gi + 1) * sizeof(GAME *));
1880 g[gi] = Calloc(1, sizeof(struct game_s));
1881 memcpy(g[gi], game[i], sizeof(struct game_s));
1882 g[gi]->tag = game[i]->tag;
1883 g[gi]->history = game[i]->history;
1884 g[gi]->hp = game[i]->hp;
1885 gi++;
1886 }
1887
1888 game = g;
1889 gtotal = gi;
1890
1891 if (which != -1) {
1892 if (which + 1 >= gtotal)
1893 gindex = gtotal - 1;
1894 else
1895 gindex = which;
1896 }
1897 else
1898 gindex = gtotal - 1;
1899
1900 gp = game[gindex];
1901 gp->hp = gp->history;
1902 }
1903
1904 /*
1905 * FIXME find across multiple games.
1906 */
1907 static int find_move_exp(GAME g, regex_t r, int which, int count)
1908 {
1909 int i;
1910 int ret;
1911 char errbuf[255];
1912 int incr;
1913 int found;
1914
1915 incr = (which == 0) ? -1 : 1;
1916
1917 for (i = g->hindex + incr - 1, found = 0; ; i += incr) {
1918 if (i == g->hindex - 1)
1919 break;
1920
1921 if (i >= pgn_history_total(g->hp))
1922 i = 0;
1923 else if (i < 0)
1924 i = pgn_history_total(g->hp) - 1;
1925
1926 // FIXME RAV
1927 ret = regexec(&r, g->hp[i]->move, 0, 0, 0);
1928
1929 if (ret == 0) {
1930 if (count == ++found) {
1931 return i + 1;
1932 }
1933 }
1934 else {
1935 if (ret != REG_NOMATCH) {
1936 regerror(ret, &r, errbuf, sizeof(errbuf));
1937 cmessage(_("Error Matching Regular Expression"), ANY_KEY_STR, "%s", errbuf);
1938 return -1;
1939 }
1940 }
1941 }
1942
1943 return -1;
1944 }
1945
1946 static int toggle_delete_flag(int n)
1947 {
1948 int i, x;
1949 struct userdata_s *d = game[n]->data;
1950
1951 TOGGLE_FLAG(d->flags, CF_DELETE);
1952 gindex = n;
1953
1954 for (i = x = 0; i < gtotal; i++) {
1955 d = game[i]->data;
1956
1957 if (TEST_FLAG(d->flags, CF_DELETE))
1958 x++;
1959 }
1960
1961 if (x == gtotal) {
1962 cmessage(NULL, ANY_KEY_STR, "%s", _("Cannot delete last game."));
1963 d = game[n]->data;
1964 CLEAR_FLAG(d->flags, CF_DELETE);
1965 return 1;
1966 }
1967
1968 return 0;
1969 }
1970
1971 static int find_game_exp(char *str, int which, int count)
1972 {
1973 char *nstr = NULL, *exp = NULL;
1974 regex_t nexp, vexp;
1975 int ret = -1;
1976 int g = 0;
1977 char buf[255] = {0}, *tmp;
1978 char errbuf[255];
1979 int found = 0;
1980 int incr = (which == 0) ? -(1) : 1;
1981
1982 strncpy(buf, str, sizeof(buf)-1);
1983 tmp = buf;
1984
1985 if (strstr(tmp, ":") != NULL) {
1986 nstr = strsep(&tmp, ":");
1987
1988 if ((ret = regcomp(&nexp, nstr,
1989 REG_ICASE|REG_EXTENDED|REG_NOSUB)) != 0) {
1990 regerror(ret, &nexp, errbuf, sizeof(errbuf));
1991 cmessage(_("Error Compiling Regular Expression"), ANY_KEY_STR, "%s", errbuf);
1992 ret = g = -1;
1993 goto cleanup;
1994 }
1995 }
1996
1997 exp = tmp;
1998
1999 while (*exp && isspace(*exp))
2000 exp++;
2001
2002 if (exp == NULL)
2003 goto cleanup;
2004
2005 if ((ret = regcomp(&vexp, exp, REG_EXTENDED|REG_NOSUB)) != 0) {
2006 regerror(ret, &vexp, errbuf, sizeof(errbuf));
2007 cmessage(_("Error Compiling Regular Expression"), ANY_KEY_STR, "%s", errbuf);
2008 ret = -1;
2009 goto cleanup;
2010 }
2011
2012 ret = -1;
2013
2014 for (g = gindex + incr, found = 0; ; g += incr) {
2015 int t;
2016
2017 if (g == gtotal)
2018 g = 0;
2019 else if (g < 0)
2020 g = gtotal - 1;
2021
2022 if (g == gindex)
2023 break;
2024
2025 for (t = 0; game[g]->tag[t]; t++) {
2026 if (nstr) {
2027 if (regexec(&nexp, game[g]->tag[t]->name, 0, 0, 0) == 0) {
2028 if (regexec(&vexp, game[g]->tag[t]->value, 0, 0, 0) == 0) {
2029 if (count == ++found) {
2030 ret = g;
2031 goto cleanup;
2032 }
2033 }
2034 }
2035 }
2036 else {
2037 if (regexec(&vexp, game[g]->tag[t]->value, 0, 0, 0) == 0) {
2038 if (count == ++found) {
2039 ret = g;
2040 goto cleanup;
2041 }
2042 }
2043 }
2044 }
2045
2046 ret = -1;
2047 }
2048
2049 cleanup:
2050 if (nstr)
2051 regfree(&nexp);
2052
2053 if (g != -1)
2054 regfree(&vexp);
2055
2056 return ret;
2057 }
2058
2059 /*
2060 * Updates the notification line in the status window then refreshes the
2061 * status window.
2062 */
2063 void update_status_notify(GAME g, char *fmt, ...)
2064 {
2065 va_list ap;
2066 #ifdef HAVE_VASPRINTF
2067 char *line;
2068 #else
2069 char line[COLS];
2070 #endif
2071
2072 if (!fmt) {
2073 if (status.notify) {
2074 free(status.notify);
2075 status.notify = NULL;
2076 }
2077
2078 return;
2079 }
2080
2081 va_start(ap, fmt);
2082 #ifdef HAVE_VASPRINTF
2083 vasprintf(&line, fmt, ap);
2084 #else
2085 vsnprintf(line, sizeof(line), fmt, ap);
2086 #endif
2087 va_end(ap);
2088
2089 if (status.notify)
2090 free(status.notify);
2091
2092 status.notify = str_to_wchar(line);
2093
2094 #ifdef HAVE_VASPRINTF
2095 free(line);
2096 #endif
2097 }
2098
2099 int rav_next_prev(GAME g, BOARD b, int n)
2100 {
2101 // Next RAV.
2102 if (n) {
2103 if ((!g->ravlevel && g->hindex && g->hp[g->hindex - 1]->rav == NULL) ||
2104 (!g->ravlevel && !g->hindex && g->hp[g->hindex]->rav == NULL) ||
2105 (g->ravlevel && g->hp[g->hindex]->rav == NULL))
2106 return 1;
2107
2108 g->rav = Realloc(g->rav, (g->ravlevel + 1) * sizeof(RAV));
2109 g->rav[g->ravlevel].hp = g->hp;
2110 g->rav[g->ravlevel].flags = g->flags;
2111 g->rav[g->ravlevel].fen = pgn_game_to_fen(g, b);
2112 g->rav[g->ravlevel].hindex = g->hindex;
2113 g->hp = (!g->ravlevel) ? (g->hindex) ? g->hp[g->hindex - 1]->rav : g->hp[g->hindex]->rav : g->hp[g->hindex]->rav;
2114 g->hindex = 0;
2115 g->ravlevel++;
2116 pgn_board_update(g, b, g->hindex + 1);
2117 return 0;
2118 }
2119
2120 if (g->ravlevel - 1 < 0)
2121 return 1;
2122
2123 // Previous RAV.
2124 g->ravlevel--;
2125 pgn_board_init_fen(g, b, g->rav[g->ravlevel].fen);
2126 free(g->rav[g->ravlevel].fen);
2127 g->hp = g->rav[g->ravlevel].hp;
2128 g->flags = g->rav[g->ravlevel].flags;
2129 g->hindex = g->rav[g->ravlevel].hindex;
2130 return 0;
2131 }
2132
2133 static void draw_window_decor()
2134 {
2135 move_panel(boardp, 0,
2136 (config.boardleft) ? 0 : COLS - BOARD_WIDTH);
2137 move_panel(historyp, LINES - HISTORY_HEIGHT,
2138 (config.boardleft) ? (MEGA_BOARD) ? BOARD_WIDTH : 0 :
2139 (MEGA_BOARD) ? 0 : COLS - HISTORY_WIDTH);
2140 move_panel(statusp, 0,
2141 (config.boardleft) ? BOARD_WIDTH : 0);
2142 move_panel(tagp, STATUS_HEIGHT + 1,
2143 (config.boardleft) ? (MEGA_BOARD) ? BOARD_WIDTH :
2144 HISTORY_WIDTH : 0);
2145
2146 wbkgd(boardw, CP_BOARD_WINDOW);
2147 wbkgd(statusw, CP_STATUS_WINDOW);
2148 window_draw_title(statusw, _("Game Status"), STATUS_WIDTH,
2149 CP_STATUS_TITLE, CP_STATUS_BORDER);
2150 wbkgd(tagw, CP_TAG_WINDOW);
2151 window_draw_title(tagw, _("Roster Tags"), TAG_WIDTH, CP_TAG_TITLE,
2152 CP_TAG_BORDER);
2153 wbkgd(historyw, CP_HISTORY_WINDOW);
2154 window_draw_title(historyw, _("Move History"), HISTORY_WIDTH,
2155 CP_HISTORY_TITLE, CP_HISTORY_BORDER);
2156 }
2157
2158 static void do_window_resize()
2159 {
2160 if (LINES < 23 || COLS < 74)
2161 return;
2162
2163 resizeterm(LINES, COLS);
2164 endwin();
2165 wresize(boardw, BOARD_HEIGHT, BOARD_WIDTH);
2166 wresize(historyw, HISTORY_HEIGHT, HISTORY_WIDTH);
2167 wresize(statusw, STATUS_HEIGHT, STATUS_WIDTH);
2168 wresize(tagw, TAG_HEIGHT, TAG_WIDTH);
2169 clear ();
2170 wclear (boardw);
2171 wclear (historyw);
2172 wclear (tagw);
2173 wclear (statusw);
2174 wclear (loadingw);
2175 wclear (enginew);
2176 draw_window_decor();
2177 update_all(gp);
2178 keypad(boardw, TRUE);
2179 curs_set(0);
2180 cbreak();
2181 noecho();
2182 }
2183
2184 void stop_clock()
2185 {
2186 memset(&clock_timer, 0, sizeof(struct itimerval));
2187 setitimer(ITIMER_REAL, &clock_timer, NULL);
2188 }
2189
2190 void start_clock(GAME g)
2191 {
2192 struct userdata_s *d = g->data;
2193
2194 if (clock_timer.it_interval.tv_usec)
2195 return;
2196
2197 memset(&d->elapsed, 0, sizeof(struct timeval));
2198 clock_timer.it_value.tv_sec = 0;
2199 clock_timer.it_value.tv_usec = 100000;
2200 clock_timer.it_interval.tv_sec = 0;
2201 clock_timer.it_interval.tv_usec = 100000;
2202 setitimer(ITIMER_REAL, &clock_timer, NULL);
2203 }
2204
2205 static void update_clocks()
2206 {
2207 int i;
2208 struct userdata_s *d;
2209 struct itimerval it;
2210 int update = 0;
2211
2212 getitimer(ITIMER_REAL, &it);
2213
2214 for (i = 0; i < gtotal; i++) {
2215 d = game[i]->data;
2216
2217 if (d && d->mode == MODE_PLAY) {
2218 if (d->paused == 1 || TEST_FLAG(d->flags, CF_NEW))
2219 continue;
2220 else if (d->paused == -1) {
2221 if (game[i]->side == game[i]->turn) {
2222 d->paused = 1;
2223 continue;
2224 }
2225 }
2226
2227 update_clock(game[i], it);
2228
2229 if (game[i] == gp)
2230 update = 1;
2231 }
2232 }
2233
2234 if (update) {
2235 update_status_window(gp);
2236 update_panels();
2237 doupdate();
2238 }
2239 }
2240
2241 #define SKIP_SPACE(str) { while (isspace(*str)) str++; }
2242
2243 static int parse_clock_time(char **str)
2244 {
2245 char *p = *str;
2246 int n = 0, t = 0;
2247
2248 SKIP_SPACE(p);
2249
2250 if (!isdigit(*p))
2251 return -1;
2252
2253 while (*p) {
2254 if (isdigit(*p)) {
2255 t = atoi(p);
2256
2257 while (isdigit(*p))
2258 p++;
2259
2260 continue;
2261 }
2262
2263 switch (*p) {
2264 case 'H':
2265 case 'h':
2266 n += t * (60 * 60);
2267 t = 0;
2268 break;
2269 case 'M':
2270 case 'm':
2271 n += t * 60;
2272 t = 0;
2273 break;
2274 case 'S':
2275 case 's':
2276 n += t;
2277 t = 0;
2278 break;
2279 case ' ':
2280 p++;
2281 case '/':
2282 case '+':
2283 goto done;
2284 default:
2285 *str = p;
2286 return -1;
2287 }
2288
2289 p++;
2290 }
2291
2292 done:
2293 n += t;
2294 *str = p;
2295 return n;
2296 }
2297
2298 static int parse_clock_input(struct clock_s *clk, char *str, int *incr)
2299 {
2300 char *p = str;
2301 long n = 0;
2302 int plus = 0;
2303 int m = 0;
2304 int tc = 0;
2305
2306 SKIP_SPACE(p);
2307
2308 if (!*p)
2309 return 0;
2310
2311 if (*p == '+') {
2312 plus = 1;
2313 p++;
2314 SKIP_SPACE(p);
2315
2316 if (*p == '+')
2317 goto move_incr;
2318 }
2319 else
2320 memset(clk, 0, sizeof(struct clock_s));
2321
2322 again:
2323 /* Sudden death. */
2324 if (strncasecmp(p, "SD", 2) == 0) {
2325 n = 0;
2326 p += 2;
2327 goto tc;
2328 }
2329
2330 n = parse_clock_time(&p);
2331
2332 if (n == -1)
2333 return 1;
2334
2335 if (!n)
2336 goto done;
2337
2338 /* Time control. */
2339 tc:
2340 if (*p == '/') {
2341 if (plus)
2342 return 1;
2343
2344 /* Sudden death without a previous time control. */
2345 if (!n && !tc)
2346 return 1;
2347
2348 m = n;
2349 p++;
2350 n = parse_clock_time(&p);
2351
2352 if (n == -1)
2353 return 1;
2354
2355 if (tc >= MAX_TC) {
2356 message(ERROR_STR, ANY_KEY_STR, "%s (%i)", _("Maximum number of time controls reached"), MAX_TC);
2357 return 1;
2358 }
2359
2360 clk->tc[tc][0] = m;
2361 clk->tc[tc++][1] = n;
2362 SKIP_SPACE(p);
2363
2364 if (*p == '+')
2365 goto move_incr;
2366
2367 if (*p)
2368 goto again;
2369
2370 goto done;
2371 }
2372
2373 if (plus)
2374 *incr = n;
2375 else
2376 clk->tc[clk->tcn][1] = (n <= clk->elapsed.tv_sec) ? clk->elapsed.tv_sec + n : n;
2377
2378 move_incr:
2379 if (*p) {
2380 if (*p++ == '+') {
2381 if (!isdigit(*p))
2382 return 1;
2383
2384 n = parse_clock_time(&p);
2385
2386 if (n == -1 || *p)
2387 return 1;
2388
2389 clk->incr = n;
2390
2391 SKIP_SPACE(p);
2392
2393 if (*p)
2394 return 1;
2395 }
2396 else
2397 return 1;
2398 }
2399
2400 done:
2401 return 0;
2402 }
2403
2404 static int parse_which_clock(struct clock_s *clk, char *str)
2405 {
2406 struct clock_s tmp;
2407 int incr = 0;
2408
2409 memcpy(&tmp, clk, sizeof(struct clock_s));
2410
2411 if (parse_clock_input(&tmp, str, &incr)) {
2412 cmessage(ERROR_STR, ANY_KEY_STR, _("Invalid clock specification"));
2413 return 1;
2414 }
2415
2416 memcpy(clk, &tmp, sizeof(struct clock_s));
2417 clk->tc[clk->tcn][1] += incr;
2418 return 0;
2419 }
2420
2421 void do_clock_input_finalize(WIN *win)
2422 {
2423 struct userdata_s *d = gp->data;
2424 struct input_data_s *in = win->data;
2425 char *p = in->str;
2426
2427 if (!in->str) {
2428 free(in);
2429 return;
2430 }
2431
2432 SKIP_SPACE(p);
2433
2434 if (tolower(*p) == 'w') {
2435 p++;
2436
2437 if (parse_which_clock(&d->wclock, p))
2438 goto done;
2439 }
2440 else if (tolower(*p) == 'b') {
2441 p++;
2442
2443 if (parse_which_clock(&d->bclock, p))
2444 goto done;
2445 }
2446 else {
2447 if (parse_which_clock(&d->wclock, p))
2448 goto done;
2449
2450 if (parse_which_clock(&d->bclock, p))
2451 goto done;
2452 }
2453
2454 if (!d->wclock.tc[0][1] && !d->bclock.tc[0][1])
2455 CLEAR_FLAG(d->flags, CF_CLOCK);
2456 else
2457 SET_FLAG(d->flags, CF_CLOCK);
2458
2459 done:
2460 free(in->str);
2461 free(in);
2462 }
2463
2464 void do_engine_command_finalize(WIN *win)
2465 {
2466 struct userdata_s *d = gp->data;
2467 struct input_data_s *in = win->data;
2468 int x;
2469
2470 if (!in->str) {
2471 free(in);
2472 return;
2473 }
2474
2475 if (!d->engine)
2476 goto done;
2477
2478 x = d->engine->status;
2479 send_to_engine(gp, -1, "%s\n", in->str);
2480 d->engine->status = x;
2481
2482 done:
2483 free(in->str);
2484 free(in);
2485 }
2486
2487 void do_board_details()
2488 {
2489 config.details = (config.details) ? 0 : 1;
2490 }
2491
2492 void do_toggle_strict_castling()
2493 {
2494 int n;
2495
2496 pgn_config_get(PGN_STRICT_CASTLING, &n);
2497
2498 if (n == 0)
2499 pgn_config_set(PGN_STRICT_CASTLING, 1);
2500 else
2501 pgn_config_set(PGN_STRICT_CASTLING, 0);
2502 }
2503
2504 void do_play_set_clock()
2505 {
2506 struct input_data_s *in;
2507
2508 in = Calloc(1, sizeof(struct input_data_s));
2509 in->efunc = do_clock_input_finalize;
2510 construct_input(_("Set Clock"), NULL, 1, 1,
2511 _ ("Format: [W | B] [+]T[+I] | ++I | M/T [M/T [...] [SD/T]] [+I]\n" \
2512 "T = time (hms), I = increment, M = moves per, SD = sudden death\ne.g., 30m or 4m+12s or 35/90m SD/30m"),
2513 NULL, NULL, 0, in, INPUT_HIST_CLOCK, -1);
2514 }
2515
2516 void do_play_toggle_human()
2517 {
2518 struct userdata_s *d = gp->data;
2519
2520 TOGGLE_FLAG(d->flags, CF_HUMAN);
2521
2522 if (!TEST_FLAG(d->flags, CF_HUMAN) && pgn_history_total(gp->hp)) {
2523 if (init_chess_engine(gp))
2524 return;
2525 }
2526
2527 CLEAR_FLAG(d->flags, CF_ENGINE_LOOP);
2528
2529 if (d->engine)
2530 d->engine->status = ENGINE_READY;
2531 }
2532
2533 void do_play_toggle_engine()
2534 {
2535 struct userdata_s *d = gp->data;
2536
2537 TOGGLE_FLAG(d->flags, CF_ENGINE_LOOP);
2538 CLEAR_FLAG(d->flags, CF_HUMAN);
2539
2540 if (d->engine && TEST_FLAG(d->flags, CF_ENGINE_LOOP)) {
2541 char *fen = pgn_game_to_fen (gp, d->b);
2542
2543 pgn_board_update(gp, d->b,
2544 pgn_history_total(gp->hp));
2545 add_engine_command(gp, ENGINE_READY, "setboard %s\n", fen);
2546 free (fen);
2547 }
2548 }
2549
2550 /*
2551 * This will send a command to the engine skipping the command queue.
2552 */
2553 void do_play_send_command()
2554 {
2555 struct userdata_s *d = gp->data;
2556 struct input_data_s *in;
2557
2558 if (!d->engine || d->engine->status == ENGINE_OFFLINE) {
2559 if (init_chess_engine(gp))
2560 return;
2561 }
2562
2563 in = Calloc(1, sizeof(struct input_data_s));
2564 in->efunc = do_engine_command_finalize;
2565 construct_input(_("Engine Command"), NULL, 1, 1, NULL, NULL, NULL, 0, in, INPUT_HIST_ENGINE, -1);
2566 }
2567 /*
2568 void do_play_switch_turn()
2569 {
2570 struct userdata_s *d = gp->data;
2571
2572 pgn_switch_side(gp);
2573 pgn_switch_turn(gp);
2574
2575 if (!TEST_FLAG(d->flags, CF_HUMAN))
2576 add_engine_command(gp, -1,
2577 (gp->side == WHITE) ? "white\n" : "black\n");
2578
2579 update_status_window(gp);
2580 }
2581 */
2582 void do_play_toggle_eh_mode()
2583 {
2584 struct userdata_s *d = gp->data;
2585
2586 if (!TEST_FLAG(d->flags, CF_HUMAN)) {
2587 if (!gp->hindex){
2588 pgn_switch_side(gp, TRUE);
2589 d->play_mode = (d->play_mode) ? PLAY_HE : PLAY_EH;
2590 if (gp->side == BLACK)
2591 update_status_notify(gp, _("Press 'g' to start the game"));
2592
2593 rotate = (rotate) ? FALSE : TRUE;
2594 }
2595 else
2596 message(NULL, ANY_KEY_STR,
2597 _("You may only switch sides at the start of the \n"
2598 "game. Press ^K or ^N to begin a new game."));
2599 }
2600 }
2601
2602 void do_play_undo()
2603 {
2604 struct userdata_s *d = gp->data;
2605
2606 if (!pgn_history_total(gp->hp))
2607 return;
2608
2609 if (keycount) {
2610 if (gp->hindex - keycount < 0)
2611 gp->hindex = 0;
2612 else {
2613 if (go_move)
2614 gp->hindex -= (keycount * 2) -1;
2615 else
2616 gp->hindex -= keycount * 2;
2617 }
2618 }
2619 else {
2620 if (gp->hindex - 2 < 0)
2621 gp->hindex = 0;
2622 else {
2623 if (go_move)
2624 gp->hindex -= 1;
2625 else
2626 gp->hindex -= 2;
2627 }
2628 }
2629
2630 pgn_history_free(gp->hp, gp->hindex);
2631 gp->hindex = pgn_history_total(gp->hp);
2632 pgn_board_update(gp, d->b, gp->hindex);
2633
2634 if (d->engine && d->engine->status == ENGINE_READY) {
2635 char *fen = pgn_game_to_fen(gp, d->b);
2636
2637 add_engine_command(gp, ENGINE_READY, "setboard %s\n", fen);
2638 free (fen);
2639 d->engine->status = ENGINE_READY;
2640 }
2641
2642 update_history_window(gp);
2643
2644 if (go_move) {
2645 pgn_switch_side(gp, FALSE);
2646 go_move--;
2647 }
2648 }
2649
2650 void do_play_toggle_pause()
2651 {
2652 struct userdata_s *d = gp->data;
2653
2654 if (!TEST_FLAG(d->flags, CF_HUMAN) && gp->turn !=
2655 gp->side) {
2656 d->paused = -1;
2657 return;
2658 }
2659
2660 d->paused = (d->paused) ? 0 : 1;
2661 }
2662
2663 void do_play_go()
2664 {
2665 struct userdata_s *d = gp->data;
2666
2667 if (TEST_FLAG(d->flags, CF_HUMAN))
2668 return;
2669
2670 if (fm_loaded_file && gp->side != gp->turn) {
2671 pgn_switch_side(gp, FALSE);
2672 add_engine_command(gp, ENGINE_THINKING, "black\n");
2673 }
2674
2675 add_engine_command(gp, ENGINE_THINKING, "go\n");
2676
2677 // Completa la función para que permita seguir jugando al usarla.
2678 // Complete the function to allow continue playing when using.
2679 if (gp->side == gp->turn)
2680 pgn_switch_side(gp, FALSE);
2681
2682 go_move++;
2683 }
2684
2685 void do_play_config_command()
2686 {
2687 int x, w;
2688
2689 if (config.keys) {
2690 for (x = 0; config.keys[x]; x++) {
2691 if (config.keys[x]->c == input_c) {
2692 switch (config.keys[x]->type) {
2693 case KEY_DEFAULT:
2694 add_engine_command(gp, -1, "%ls\n",
2695 config.keys[x]->str);
2696 break;
2697 case KEY_SET:
2698 if (!keycount)
2699 break;
2700
2701 add_engine_command(gp, -1,
2702 "%ls %i\n", config.keys[x]->str, keycount);
2703 keycount = 0;
2704 break;
2705 case KEY_REPEAT:
2706 if (!keycount)
2707 break;
2708
2709 for (w = 0; w < keycount; w++)
2710 add_engine_command(gp, -1,
2711 "%ls\n", config.keys[x]->str);
2712 keycount = 0;
2713 break;
2714 }
2715 }
2716 }
2717 }
2718
2719 update_status_notify(gp, NULL);
2720 }
2721
2722 void do_play_cancel_selected()
2723 {
2724 struct userdata_s *d = gp->data;
2725
2726 d->sp.icon = d->sp.srow = d->sp.scol = 0;
2727 keycount = 0;
2728 pgn_reset_valid_moves(d->b);
2729 update_status_notify(gp, NULL);
2730 }
2731
2732 void do_play_commit()
2733 {
2734 struct userdata_s *d = gp->data;
2735
2736 pushkey = keycount = 0;
2737 update_status_notify(gp, NULL);
2738
2739 if (!TEST_FLAG(d->flags, CF_HUMAN) &&
2740 (!d->engine || d->engine->status == ENGINE_THINKING))
2741 return;
2742
2743 if (!d->sp.icon)
2744 return;
2745
2746 d->sp.row = d->c_row;
2747 d->sp.col = d->c_col;
2748
2749 if (rotate) {
2750 rotate_position(SP_POSITION);
2751 rotate_position(SPS_POSITION);
2752 }
2753
2754 move_to_engine(gp);
2755
2756 // Completa la función para que permita seguir jugando cuando se carga un
2757 // archivo pgn (con juego no terminado) que inicie con turno del lado
2758 // negro.
2759 // Complete the function to allow continue playing when loading a file
2760 // pgn (with unfinished game) you start to turn black side.
2761 if (gp->side != gp->turn)
2762 pgn_switch_side(gp, FALSE);
2763
2764 if (rotate && d->sp.icon)
2765 rotate_position(SPS_POSITION);
2766
2767 // Envia comando 'go' a Polyglot en el primer movimiento debido a que
2768 // polyglot no envia el movimiento y cboard se queda esperando.
2769 // Send command 'go' to the first movement Polyglot because cboard
2770 // waits to send polyglot movement and this does not make.
2771 if (config.fmpolyglot &&
2772 ((gp->side == WHITE && !gp->hindex) || fm_loaded_file))
2773 add_engine_command(gp, ENGINE_THINKING, "go\n");
2774
2775 go_move = 0;
2776 fm_loaded_file = FALSE;
2777 }
2778
2779 void do_play_select()
2780 {
2781 struct userdata_s *d = gp->data;
2782
2783 if (!TEST_FLAG(d->flags, CF_HUMAN) && (!d->engine ||
2784 d->engine->status == ENGINE_OFFLINE)) {
2785 if (init_chess_engine(gp))
2786 return;
2787 }
2788
2789 if (d->engine && d->engine->status == ENGINE_THINKING)
2790 return;
2791
2792 if (d->sp.icon)
2793 do_play_cancel_selected ();
2794
2795 if (rotate)
2796 rotate_position(CURSOR_POSITION);
2797
2798 d->sp.icon = d->b[RANKTOBOARD(d->c_row)][FILETOBOARD(d->c_col)].icon;
2799
2800 if (pgn_piece_to_int(d->sp.icon) == OPEN_SQUARE) {
2801 d->sp.icon = 0;
2802 return;
2803 }
2804
2805 if (((islower(d->sp.icon) && gp->turn != BLACK)
2806 || (isupper(d->sp.icon) && gp->turn != WHITE))) {
2807 struct key_s **k;
2808 char *str = Malloc (512);
2809
2810 for (k = play_keys; *k; k++) {
2811 if ((*k)->f == do_play_toggle_eh_mode)
2812 break;
2813 }
2814
2815 snprintf (str, 512, _("It is not your turn to move. You may switch playing sides by pressing \"%lc\"."),
2816 *k ? (*k)->c : '?');
2817 message(NULL, ANY_KEY_STR, "%s", str);
2818 free (str);
2819 d->sp.icon = 0;
2820 return;
2821 #if 0
2822 if (pgn_history_total(gp->hp)) {
2823 message(NULL, ANY_KEY_STR, "%s", _("It is not your turn to move. You can switch sides "));
2824 d->sp.icon = 0;
2825 return;
2826 }
2827 else {
2828 if (pgn_tag_find(gp->tag, "FEN") != E_PGN_ERR)
2829 return;
2830
2831 add_engine_command(gp, ENGINE_READY, "black\n");
2832 pgn_switch_turn(gp);
2833
2834 if (gp->side != BLACK)
2835 pgn_switch_side(gp);
2836 }
2837 #endif
2838 }
2839
2840 d->sp.srow = d->c_row;
2841 d->sp.scol = d->c_col;
2842
2843 if (config.validmoves)
2844 pgn_find_valid_moves(gp, d->b, d->sp.scol, d->sp.srow);
2845
2846 if (rotate) {
2847 rotate_position(CURSOR_POSITION);
2848 rotate_position(SPS_POSITION);
2849 }
2850
2851 CLEAR_FLAG(d->flags, CF_NEW);
2852 start_clock(gp);
2853 }
2854
2855 /* FIXME: keys with the same function should comma deliminated. */
2856 static wchar_t *build_help(struct key_s **keys)
2857 {
2858 int i, nlen = 1, len, t, n;
2859 wchar_t *buf = NULL, *wc = NULL;
2860 wchar_t *p;
2861
2862 if (!keys)
2863 return NULL;
2864
2865 for (i = len = t = 0; keys[i]; i++) {
2866 if (!keys[i]->d)
2867 continue;
2868
2869 if (keys[i]->key) {
2870 if (wcslen(keys[i]->key) > nlen) {
2871 nlen = wcslen(keys[i]->key);
2872 t += nlen;
2873 }
2874 else
2875 t++;
2876 }
2877
2878 if (keys[i]->d) {
2879 if (wcslen(keys[i]->d) > len)
2880 len = wcslen(keys[i]->d);
2881 }
2882
2883 t += len;
2884 t += keys[i]->r;
2885 }
2886
2887 t += 4 + i;
2888 buf = Malloc(t*sizeof(wchar_t));
2889 p = buf;
2890
2891 for (i = 0; keys[i]; i++) {
2892 if (!keys[i]->d)
2893 continue;
2894
2895 if (keys[i]->key)
2896 n = wcslen(keys[i]->key);
2897 else
2898 n = 1;
2899
2900 while (n++ <= nlen)
2901 *p++ = ' ';
2902
2903 *p = 0;
2904
2905 if (keys[i]->key) {
2906 wcscat(buf, keys[i]->key);
2907 p = buf + wcslen(buf);
2908 }
2909 else
2910 *p++ = keys[i]->c;
2911
2912 *p++ = ' ';
2913 *p++ = '-';
2914 *p++ = ' ';
2915 *p = 0;
2916
2917 if (keys[i]->d)
2918 wcscat(buf, keys[i]->d);
2919
2920 if (keys[i]->r) {
2921 wc = str_to_wchar ("*");
2922 wcscat(buf, wc);
2923 free (wc);
2924 }
2925
2926 wc = str_to_wchar ("\n");
2927 wcscat(buf, wc);
2928 free (wc);
2929 p = buf + wcslen(buf);
2930 }
2931
2932 return buf;
2933 }
2934
2935 void do_more_help(WIN *);
2936 void do_main_help(WIN *win)
2937 {
2938 wchar_t *buf;
2939
2940 switch (win->c) {
2941 case 'p':
2942 buf = build_help(play_keys);
2943 construct_message(_("Play Mode Keys (* = can take a repeat count)"), ANY_KEY_STR, 0, 0,
2944 NULL, NULL, buf, do_more_help, 0, 1, "%ls", buf);
2945 break;
2946 case 'h':
2947 buf = build_help(history_keys);
2948 construct_message(_("History Mode Keys (* = can take a repeat count)"), ANY_KEY_STR, 0, 0,
2949 NULL, NULL, buf, do_more_help, 0, 1, "%ls", buf);
2950 break;
2951 case 'e':
2952 buf = build_help(edit_keys);
2953 construct_message(_("Edit Mode Keys (* = can take a repeat count)"), ANY_KEY_STR, 0, 0,
2954 NULL, NULL, buf, do_more_help, 0, 1, "%ls", buf);
2955 break;
2956 case 'g':
2957 buf = build_help(global_keys);
2958 construct_message(_("Global Game Keys (* = can take a repeat count)"), ANY_KEY_STR, 0, 0,
2959 NULL, NULL, buf, do_more_help, 0, 1, "%ls", buf);
2960 break;
2961 default:
2962 break;
2963 }
2964 }
2965
2966 void do_more_help(WIN *win)
2967 {
2968 if (win->c == KEY_F(1) || win->c == CTRL_KEY('g'))
2969 construct_message(_("Command Key Index"),
2970 _ ("p/h/e/g or any other key to quit"), 0, 0,
2971 NULL, NULL, NULL, do_main_help, 0, 0, "%s",
2972 _ (
2973 "p - play mode keys\n"
2974 "h - history mode keys\n"
2975 "e - board edit mode keys\n"
2976 "g - global game keys"
2977 ));
2978 }
2979
2980 void do_play_help()
2981 {
2982 wchar_t *buf = build_help(play_keys);
2983
2984 construct_message(_("Play Mode Keys (* = can take a repeat count)"),
2985 ANY_KEY_STR, 0, 0, NULL, NULL,
2986 buf, do_more_help, 0, 1, "%ls", buf);
2987 }
2988
2989 void do_play_history_mode()
2990 {
2991 struct userdata_s *d = gp->data;
2992
2993 if (!pgn_history_total(gp->hp) ||
2994 (d->engine && d->engine->status == ENGINE_THINKING))
2995 return;
2996
2997 d->mode = MODE_HISTORY;
2998 pgn_board_update(gp, d->b, pgn_history_total(gp->hp));
2999 }
3000
3001 void do_play_edit_mode()
3002 {
3003 struct userdata_s *d = gp->data;
3004
3005 if (pgn_history_total(gp->hp))
3006 return;
3007
3008 pgn_board_init_fen(gp, d->b, NULL);
3009 config.details++;
3010 d->mode = MODE_EDIT;
3011 }
3012
3013 void do_edit_insert_finalize(WIN *win)
3014 {
3015 struct userdata_s *d = win->data;
3016
3017 if (pgn_piece_to_int(win->c) == -1)
3018 return;
3019
3020 d->b[RANKTOBOARD(d->c_row)][FILETOBOARD(d->c_col)].icon = win->c;
3021 }
3022
3023 void do_edit_select()
3024 {
3025 struct userdata_s *d = gp->data;
3026
3027 if (d->sp.icon)
3028 return;
3029
3030 d->sp.icon = d->b[RANKTOBOARD(d->c_row)][FILETOBOARD(d->c_col)].icon;
3031
3032 if (pgn_piece_to_int(d->sp.icon) == OPEN_SQUARE) {
3033 d->sp.icon = 0;
3034 return;
3035 }
3036
3037 d->sp.srow = d->c_row;
3038 d->sp.scol = d->c_col;
3039 }
3040
3041 void do_edit_commit()
3042 {
3043 int p;
3044 struct userdata_s *d = gp->data;
3045
3046 pushkey = keycount = 0;
3047 update_status_notify(gp, NULL);
3048
3049 if (!d->sp.icon)
3050 return;
3051
3052 d->sp.row = d->c_row;
3053 d->sp.col = d->c_col;
3054 p = d->b[RANKTOBOARD(d->sp.srow)][FILETOBOARD(d->sp.scol)].icon;
3055 d->b[RANKTOBOARD(d->sp.row)][FILETOBOARD(d->sp.col)].icon = p;
3056 d->b[RANKTOBOARD(d->sp.srow)][FILETOBOARD(d->sp.scol)].icon =
3057 pgn_int_to_piece(gp->turn, OPEN_SQUARE);
3058 d->sp.icon = d->sp.srow = d->sp.scol = 0;
3059 }
3060
3061 void do_edit_delete()
3062 {
3063 struct userdata_s *d = gp->data;
3064
3065 if (d->sp.icon)
3066 d->b[RANKTOBOARD(d->sp.srow)][FILETOBOARD(d->sp.scol)].icon =
3067 pgn_int_to_piece(gp->turn, OPEN_SQUARE);
3068 else
3069 d->b[RANKTOBOARD(d->c_row)][FILETOBOARD(d->c_col)].icon =
3070 pgn_int_to_piece(gp->turn, OPEN_SQUARE);
3071
3072 d->sp.icon = d->sp.srow = d->sp.scol = 0;
3073 }
3074
3075 void do_edit_cancel_selected()
3076 {
3077 struct userdata_s *d = gp->data;
3078
3079 d->sp.icon = d->sp.srow = d->sp.scol = 0;
3080 keycount = 0;
3081 update_status_notify(gp, NULL);
3082 }
3083
3084 void do_edit_switch_turn()
3085 {
3086 pgn_switch_turn(gp);
3087 }
3088
3089 void do_edit_toggle_castle()
3090 {
3091 struct userdata_s *d = gp->data;
3092
3093 castling_state(gp, d->b, RANKTOBOARD(d->c_row),
3094 FILETOBOARD(d->c_col),
3095 d->b[RANKTOBOARD(d->c_row)][FILETOBOARD(d->c_col)].icon, 1);
3096 }
3097
3098 void do_edit_insert()
3099 {
3100 struct userdata_s *d = gp->data;
3101
3102 construct_message(_("Insert Piece"), _("P=pawn, R=rook, N=knight, B=bishop, "), 0, 0, NULL, NULL,
3103 d->b, do_edit_insert_finalize, 0, 0, "%s", _("Type the piece letter to insert. Lowercase "));
3104 }
3105
3106 void do_edit_enpassant()
3107 {
3108 struct userdata_s *d = gp->data;
3109
3110 if (d->c_row == 6 || d->c_row == 3) {
3111 pgn_reset_enpassant(d->b);
3112 d->b[RANKTOBOARD(d->c_row)][FILETOBOARD(d->c_col)].enpassant = 1;
3113 }
3114 }
3115
3116 void do_edit_help()
3117 {
3118 wchar_t *buf = build_help(edit_keys);
3119
3120 construct_message(_("Edit Mode Keys (* = can take a repeat count)"),
3121 ANY_KEY_STR, 0, 0, NULL, NULL,
3122 buf, do_more_help, 0, 1, "%ls", buf);
3123 }
3124
3125 void do_edit_exit()
3126 {
3127 struct userdata_s *d = gp->data;
3128 char *fen = pgn_game_to_fen(gp, d->b);
3129
3130 config.details--;
3131 pgn_tag_add(&gp->tag, "FEN", fen);
3132 free (fen);
3133 pgn_tag_add(&gp->tag, "SetUp", "1");
3134 pgn_tag_sort(gp->tag);
3135 pgn_board_update(gp, d->b, gp->hindex);
3136 d->mode = MODE_PLAY;
3137 }
3138
3139 void really_do_annotate_finalize(struct input_data_s *in,
3140 struct userdata_s *d)
3141 {
3142 HISTORY *h = in->data;
3143 int len;
3144
3145 if (!in->str) {
3146 if (h->comment) {
3147 free(h->comment);
3148 h->comment = NULL;
3149 }
3150 }
3151 else {
3152 len = strlen(in->str);
3153 h->comment = Realloc(h->comment, len+1);
3154 strncpy(h->comment, in->str, len);
3155 h->comment[len] = 0;
3156 }
3157
3158 free(in->str);
3159 free(in);
3160 SET_FLAG(d->flags, CF_MODIFIED);
3161 }
3162
3163 void do_annotate_finalize(WIN *win)
3164 {
3165 struct userdata_s *d = gp->data;
3166 struct input_data_s *in = win->data;
3167
3168 really_do_annotate_finalize(in, d);
3169 }
3170
3171 void do_find_move_exp_finalize(int init, int which)
3172 {
3173 int n;
3174 struct userdata_s *d = gp->data;
3175 static int firstrun;
3176 static regex_t r;
3177 int ret;
3178 char errbuf[255];
3179
3180 if (init || !firstrun) {
3181 if (!firstrun)
3182 regfree(&r);
3183
3184 if ((ret = regcomp(&r, moveexp, REG_EXTENDED|REG_NOSUB)) != 0) {
3185 regerror(ret, &r, errbuf, sizeof(errbuf));
3186 cmessage(_("Error Compiling Regular Expression"), ANY_KEY_STR, "%s", errbuf);
3187 return;
3188 }
3189
3190 firstrun = 1;
3191 }
3192
3193 if ((n = find_move_exp(gp, r,
3194 (which == -1) ? 0 : 1, (keycount) ? keycount : 1)) == -1)
3195 return;
3196
3197 gp->hindex = n;
3198 pgn_board_update(gp, d->b, gp->hindex);
3199 }
3200
3201 void do_find_move_exp(WIN *win)
3202 {
3203 struct input_data_s *in = win->data;
3204 int *n = in->data;
3205 int which = *n;
3206
3207 if (in->str) {
3208 strncpy(moveexp, in->str, sizeof(moveexp)-1);
3209 moveexp[sizeof(moveexp)-1] = 0;
3210 do_find_move_exp_finalize(1, which);
3211 free(in->str);
3212 }
3213
3214 free(in->data);
3215 free(in);
3216 }
3217
3218 void do_move_jump_finalize(int n)
3219 {
3220 struct userdata_s *d = gp->data;
3221
3222 if (n < 0 || n > (pgn_history_total(gp->hp) / 2))
3223 return;
3224
3225 keycount = 0;
3226 update_status_notify(gp, NULL);
3227 gp->hindex = (n) ? n * 2 - 1 : n * 2;
3228 pgn_board_update(gp, d->b, gp->hindex);
3229 }
3230
3231 void do_move_jump(WIN *win)
3232 {
3233 struct input_data_s *in = win->data;
3234
3235 if (!in->str || !isinteger(in->str)) {
3236 if (in->str)
3237 free(in->str);
3238
3239 free(in);
3240 return;
3241 }
3242
3243 do_move_jump_finalize(atoi(in->str));
3244 free(in->str);
3245 free(in);
3246 }
3247
3248 struct history_menu_s {
3249 char *line;
3250 int hindex;
3251 int ravlevel;
3252 int move;
3253 int indent;
3254 };
3255
3256 void free_history_menu_data(struct history_menu_s **h)
3257 {
3258 int i;
3259
3260 if (!h)
3261 return;
3262
3263 for (i = 0; h[i]; i++) {
3264 free(h[i]->line);
3265 free(h[i]);
3266 }
3267
3268 free(h);
3269 }
3270
3271 void get_history_data(HISTORY **hp, struct history_menu_s ***menu, int m,
3272 int turn)
3273 {
3274 int i, n = 0;
3275 int t = pgn_history_total(hp);
3276 char buf[MAX_SAN_MOVE_LEN + 4];
3277 static int depth;
3278 struct history_menu_s **hmenu = *menu;
3279
3280 if (hmenu)
3281 for (n = 0; hmenu[n]; n++);
3282 else
3283 depth = 0;
3284
3285 for (i = 0; i < t; i++) {
3286 hmenu = Realloc(hmenu, (n + 2) * sizeof(struct history_menu_s *));
3287 hmenu[n] = Malloc(sizeof(struct history_menu_s));
3288 snprintf(buf, sizeof(buf), "%c%s%s", (turn == WHITE) ? 'W' : 'B',
3289 hp[i]->move, (hp[i]->comment || hp[i]->nag[0]) ? " !" : "");
3290 hmenu[n]->line = strdup(buf);
3291 hmenu[n]->hindex = i;
3292 hmenu[n]->indent = 0;
3293 hmenu[n]->ravlevel = depth;
3294 hmenu[n]->move = (n && depth > hmenu[n-1]->ravlevel) ? m++ : m;
3295 n++;
3296 hmenu[n] = NULL;
3297
3298 #if 0
3299 if (hp[i]->rav) {
3300 depth++;
3301 get_history_data(hp[i]->rav, &hmenu, m, turn);
3302 for (n = 0; hmenu[n]; n++);
3303 depth--;
3304
3305 if (depth)
3306 m--;
3307 }
3308 #endif
3309
3310 turn = (turn == WHITE) ? BLACK : WHITE;
3311 }
3312
3313 *menu = hmenu;
3314 }
3315
3316 void history_draw_update(struct menu_input_s *m)
3317 {
3318 GAME g = m->data;
3319 struct userdata_s *d = g->data;
3320
3321 g->hindex = m->selected + 1;
3322 update_cursor(g, m->selected);
3323 pgn_board_update(g, d->b, m->selected + 1);
3324 }
3325
3326 struct menu_item_s **get_history_items(WIN *win)
3327 {
3328 struct menu_input_s *m = win->data;
3329 GAME g = m->data;
3330 struct userdata_s *d = g->data;
3331 struct history_menu_s **hm = d->data;
3332 struct menu_item_s **items = m->items;
3333 int i;
3334
3335 if (!hm) {
3336 get_history_data(g->history, &hm, 0,
3337 TEST_FLAG(g->flags, GF_BLACK_OPENING));
3338 m->selected = g->hindex - 1;
3339
3340 if (m->selected < 0)
3341 m->selected = 0;
3342
3343 m->draw_exit_func = history_draw_update;
3344 }
3345
3346 d->data = hm;
3347
3348 if (items) {
3349 for (i = 0; items[i]; i++)
3350 free(items[i]);
3351
3352 free(items);
3353 items = NULL;
3354 }
3355
3356 for (i = 0; hm[i]; i++) {
3357 items = Realloc(items, (i+2) * sizeof(struct menu_item_s *));
3358 items[i] = Malloc(sizeof(struct menu_item_s));
3359 items[i]->name = hm[i]->line;
3360 items[i]->value = NULL;
3361 items[i]->selected = 0;
3362 }
3363
3364 if (items)
3365 items[i] = NULL;
3366
3367 m->nofree = 1;
3368 m->items = items;
3369 return items;
3370 }
3371
3372 void history_menu_quit(struct menu_input_s *m)
3373 {
3374 pushkey = -1;
3375 }
3376
3377 void history_menu_exit(WIN *win)
3378 {
3379 GAME g = win->data;
3380 struct userdata_s *d = g->data;
3381 struct history_menu_s **hm = d->data;
3382 int i;
3383
3384 if (!hm)
3385 return;
3386
3387 for (i = 0; hm[i]; i++) {
3388 free(hm[i]->line);
3389 free(hm[i]);
3390 }
3391
3392 free(hm);
3393 d->data = NULL;
3394 }
3395
3396 // FIXME RAV
3397 void history_menu_next(struct menu_input_s *m)
3398 {
3399 GAME g = m->data;
3400 struct userdata_s *d = g->data;
3401 struct history_menu_s **hm = d->data;
3402 int n, t;
3403
3404 for (t = 0; hm[t]; t++);
3405
3406 if (m->selected + 1 == t)
3407 n = 0;
3408 else
3409 n = hm[m->selected + 1]->hindex;
3410
3411 n++;
3412 g->hindex = n;
3413 }
3414
3415 // FIXME RAV
3416 void history_menu_prev(struct menu_input_s *m)
3417 {
3418 GAME g = m->data;
3419 struct userdata_s *d = g->data;
3420 struct history_menu_s **hm = d->data;
3421 int n, t;
3422
3423 for (t = 0; hm[t]; t++);
3424
3425 if (m->selected - 1 < 0)
3426 n = t - 1;
3427 else
3428 n = hm[m->selected - 1]->hindex;
3429
3430 n++;
3431 g->hindex = n;
3432 }
3433
3434 void history_menu_help(struct menu_input_s *m)
3435 {
3436 message(_("History Menu Help"), ANY_KEY_STR, "%s",
3437 _ (
3438 " UP/DOWN - previous/next menu item\n"
3439 " HOME/END - first/last menu item\n"
3440 " PGDN/PGUP - next/previous page\n"
3441 " a-zA-Z0-9 - jump to item\n"
3442 " CTRL-a - annotate the selected move\n"
3443 " ENTER - view annotation\n"
3444 " CTRL-d - toggle board details\n"
3445 " ESCAPE/M - return to move history"
3446 ));
3447 }
3448
3449 void do_annotate_move(HISTORY *hp)
3450 {
3451 char buf[COLS - 4];
3452 struct input_data_s *in;
3453
3454 snprintf(buf, sizeof(buf), "%s \"%s\"", _("Editing Annotation for"), hp->move);
3455 in = Calloc(1, sizeof(struct input_data_s));
3456 in->data = hp;
3457 in->efunc = do_annotate_finalize;
3458 construct_input(buf, hp->comment, MAX_PGN_LINE_LEN / INPUT_WIDTH, 0,
3459 _("Type CTRL-t to edit NAG"), edit_nag, NULL, CTRL_KEY('T'), in, -1, -1);
3460 }
3461
3462 void history_menu_view_annotation(struct menu_input_s *m)
3463 {
3464 GAME g = m->data;
3465
3466 // FIXME RAV
3467 view_annotation(g->history[m->selected]);
3468 }
3469
3470 void history_menu_annotate_finalize(WIN *win)
3471 {
3472 struct input_data_s *in = win->data;
3473 GAME g = in->moredata;
3474 struct userdata_s *d = g->data;
3475 struct history_menu_s **hm = d->data;
3476
3477 really_do_annotate_finalize(in, d);
3478 free_history_menu_data(hm);
3479 hm = NULL;
3480 get_history_data(g->history, &hm, 0, TEST_FLAG(g->flags, GF_BLACK_OPENING));
3481 d->data = hm;
3482 pushkey = REFRESH_MENU;
3483 }
3484
3485 void history_menu_annotate(struct menu_input_s *m)
3486 {
3487 GAME g = m->data;
3488 char buf[COLS - 4];
3489 struct input_data_s *in;
3490 HISTORY *hp = g->history[m->selected]; // FIXME RAV
3491
3492 snprintf(buf, sizeof(buf), "%s \"%s\"", _("Editing Annotation for"), hp->move);
3493 in = Calloc(1, sizeof(struct input_data_s));
3494 in->data = hp;
3495 in->moredata = m->data;
3496 in->efunc = history_menu_annotate_finalize;
3497 construct_input(buf, hp->comment, MAX_PGN_LINE_LEN / INPUT_WIDTH, 0,
3498 _("Type CTRL-t to edit NAG"), edit_nag, NULL, CTRL_KEY('T'), in, -1, -1);
3499 }
3500
3501 void history_menu_details(struct menu_input_s *m)
3502 {
3503 do_board_details();
3504 }
3505
3506 // FIXME RAV
3507 void history_menu_print(WIN *win)
3508 {
3509 struct menu_input_s *m = win->data;
3510 GAME g = m->data;
3511 struct userdata_s *d = g->data;
3512 struct history_menu_s **hm = d->data;
3513 struct history_menu_s *h = hm[m->top];
3514 int i;
3515 char *p = m->item->name;
3516 int line = m->print_line - 2;
3517 /*
3518 * Solaris 5.9 doesn't have wattr_get() or any function that requires an
3519 * attr_t data type.
3520 */
3521 attr_t attrs;
3522 short pair;
3523 int total;
3524
3525 for (total = 0; hm[total]; total++);
3526 wattr_get(win->w, &attrs, &pair, NULL);
3527 wattroff(win->w, COLOR_PAIR(pair));
3528 mvwaddch(win->w, m->print_line, 1,
3529 *p == 'W' ? *p | mix_cp(CP_BOARD_WHITE, CP_HISTORY_WINDOW, ATTRS(CP_BOARD_WHITE), A_FG_B_BG) : *p | mix_cp(CP_BOARD_BLACK, CP_HISTORY_WINDOW, ATTRS(CP_BOARD_BLACK), A_FG_B_BG));
3530 p++;
3531
3532 if (h->hindex == 0 && line == 0)
3533 waddch(win->w, ACS_ULCORNER | CP_HISTORY_MENU_LG);
3534 else if ((!hm[h->hindex + (win->rows - 5) + 1] && line == win->rows - 5) ||
3535 (m->top + line == total - 1))
3536 waddch(win->w, ACS_LLCORNER | CP_HISTORY_MENU_LG);
3537 else if (hm[m->top + 1]->ravlevel != h->ravlevel || !h->ravlevel)
3538 waddch(win->w, ACS_LTEE | CP_HISTORY_MENU_LG);
3539 else
3540 waddch(win->w, ACS_VLINE | CP_HISTORY_MENU_LG);
3541
3542 wattron(win->w, COLOR_PAIR(pair) | attrs);
3543
3544 for (i = 2; *p; p++, i++)
3545 waddch(win->w, (*p == '!') ? *p | A_BOLD : *p);
3546
3547 while (i++ < win->cols - 2)
3548 waddch(win->w, ' ');
3549 }
3550
3551 void history_menu(GAME g)
3552 {
3553 struct menu_key_s **keys = NULL;
3554
3555 add_menu_key(&keys, KEY_ESCAPE, history_menu_quit);
3556 add_menu_key(&keys, 'M', history_menu_quit);
3557 add_menu_key(&keys, KEY_UP, history_menu_prev);
3558 add_menu_key(&keys, KEY_DOWN, history_menu_next);
3559 add_menu_key(&keys, KEY_F(1), history_menu_help);
3560 add_menu_key(&keys, CTRL_KEY('a'), history_menu_annotate);
3561 add_menu_key(&keys, CTRL_KEY('d'), history_menu_details);
3562 add_menu_key(&keys, '\n', history_menu_view_annotation);
3563 construct_menu(MEGA_BOARD ? LINES - HISTORY_HEIGHT_MB : LINES,
3564 TAG_WIDTH, 0, config.boardleft ? BOARD_WIDTH : 0,
3565 _("Move History Tree"), 1, get_history_items, keys, g,
3566 history_menu_print, history_menu_exit);
3567 }
3568
3569 void do_history_menu()
3570 {
3571 history_menu(gp);
3572 }
3573
3574 void do_history_half_move_toggle()
3575 {
3576 movestep = (movestep == 1) ? 2 : 1;
3577 update_history_window(gp);
3578 }
3579
3580 void do_history_rotate_board()
3581 {
3582 rotate = (rotate) ? FALSE : TRUE;
3583 }
3584
3585 void do_history_jump_next()
3586 {
3587 struct userdata_s *d = gp->data;
3588
3589 pgn_history_next(gp, d->b, (keycount > 0) ?
3590 config.jumpcount * keycount * movestep :
3591 config.jumpcount * movestep);
3592 }
3593
3594 void do_history_jump_prev()
3595 {
3596 struct userdata_s *d = gp->data;
3597
3598 pgn_history_prev(gp, d->b, (keycount) ?
3599 config.jumpcount * keycount * movestep :
3600 config.jumpcount * movestep);
3601 }
3602
3603 void do_history_prev()
3604 {
3605 struct userdata_s *d = gp->data;
3606
3607 pgn_history_prev(gp, d->b,
3608 (keycount) ? keycount * movestep : movestep);
3609 }
3610
3611 void do_history_next()
3612 {
3613 struct userdata_s *d = gp->data;
3614
3615 pgn_history_next(gp, d->b, (keycount) ?
3616 keycount * movestep : movestep);
3617 }
3618
3619 void do_history_mode_finalize(struct userdata_s *d)
3620 {
3621 pushkey = 0;
3622 d->mode = MODE_PLAY;
3623 }
3624
3625 void do_history_mode_confirm(WIN *win)
3626 {
3627 struct userdata_s *d = gp->data;
3628 wchar_t str[] = { win->c, 0 };
3629
3630 if (!wcscmp (str, resume_wchar)) {
3631 pgn_history_free(gp->hp, gp->hindex);
3632 pgn_board_update(gp, d->b, pgn_history_total(gp->hp));
3633 }
3634 #if 0
3635 case 'C':
3636 case 'c':
3637 if (pgn_history_rav_new(gp, d->b,
3638 gp->hindex) != E_PGN_OK)
3639 return;
3640
3641 break;
3642 #endif
3643 else
3644 return;
3645
3646 if (!TEST_FLAG(d->flags, CF_HUMAN)) {
3647 char *fen = pgn_game_to_fen(gp, d->b);
3648
3649 add_engine_command(gp, ENGINE_READY, "setboard %s\n", fen);
3650 free (fen);
3651 }
3652
3653 do_history_mode_finalize(d);
3654 }
3655
3656 void do_history_toggle()
3657 {
3658 struct userdata_s *d = gp->data;
3659
3660 // FIXME Resuming from previous history could append to a RAV.
3661 if (gp->hindex != pgn_history_total(gp->hp)) {
3662 if (!pushkey)
3663 construct_message(NULL, _ ("What would you like to do?"), 0, 1,
3664 NULL, NULL, NULL, do_history_mode_confirm, 0, 0,
3665 _("The current move is not the final move of this round. Press \"%ls\" to resume a game from the current move and discard future moves or any other key to cancel."),
3666 resume_wchar);
3667 return;
3668 }
3669 else {
3670 if (TEST_FLAG(gp->flags, GF_GAMEOVER))
3671 return;
3672 }
3673
3674 if (gp->side != gp->turn) {
3675 d->play_mode = PLAY_EH;
3676 }
3677 else {
3678 d->play_mode = PLAY_HE;
3679 rotate = FALSE;
3680 }
3681
3682 do_history_mode_finalize(d);
3683 }
3684
3685 void do_history_annotate()
3686 {
3687 int n = gp->hindex;
3688
3689 if (n && gp->hp[n - 1]->move)
3690 n--;
3691 else
3692 return;
3693
3694 do_annotate_move(gp->hp[n]);
3695 }
3696
3697 void do_history_help()
3698 {
3699 wchar_t *buf = build_help(history_keys);
3700
3701 construct_message(_("History Mode Keys (* = can take a repeat count)"),
3702 ANY_KEY_STR, 0, 0, NULL, NULL,
3703 buf, do_more_help, 0, 1, "%ls", buf);
3704 }
3705
3706 void do_history_find(int which)
3707 {
3708 struct input_data_s *in;
3709 int *p;
3710
3711 if (pgn_history_total(gp->hp) < 2)
3712 return;
3713
3714 in = Calloc(1, sizeof(struct input_data_s));
3715 p = Malloc(sizeof(int));
3716 *p = which;
3717 in->data = p;
3718 in->efunc = do_find_move_exp;
3719
3720 if (!*moveexp || which == 0) {
3721 construct_input(_("Find Move Text Expression"), NULL, 1, 0, NULL, NULL, NULL,
3722 0, in, INPUT_HIST_MOVE_EXP, -1);
3723 return;
3724 }
3725
3726 do_find_move_exp_finalize(0, which);
3727 }
3728
3729 void do_history_find_new()
3730 {
3731 do_history_find(0);
3732 }
3733
3734 void do_history_find_prev()
3735 {
3736 do_history_find(-1);
3737 }
3738
3739 void do_history_find_next()
3740 {
3741 do_history_find(1);
3742 }
3743
3744 void do_history_rav(int which)
3745 {
3746 struct userdata_s *d = gp->data;
3747
3748 rav_next_prev(gp, d->b, which);
3749 }
3750
3751 void do_history_rav_next()
3752 {
3753 do_history_rav(1);
3754 }
3755
3756 void do_history_rav_prev()
3757 {
3758 do_history_rav(0);
3759 }
3760
3761 void do_history_jump()
3762 {
3763 struct input_data_s *in;
3764
3765 if (pgn_history_total(gp->hp) < 2)
3766 return;
3767
3768 if (!keycount) {
3769 in = Calloc(1, sizeof(struct input_data_s));
3770 in->efunc = do_move_jump;
3771
3772 construct_input(_("Jump to Move Number"), NULL, 1, 1, NULL,
3773 NULL, NULL, 0, in, -1, 0);
3774 return;
3775 }
3776
3777 do_move_jump_finalize(keycount);
3778 }
3779
3780 static void free_userdata_once(GAME g)
3781 {
3782 struct userdata_s *d = g->data;
3783
3784 if (!d)
3785 return;
3786
3787 if (d->engine) {
3788 stop_engine(g);
3789
3790 if (d->engine->enginebuf) {
3791 int n;
3792
3793 for (n = 0; d->engine->enginebuf[n]; n++)
3794 free(d->engine->enginebuf[n]);
3795
3796 free(d->engine->enginebuf);
3797 }
3798
3799 if (d->engine->queue) {
3800 struct queue_s **q;
3801
3802 for (q = d->engine->queue; *q; q++)
3803 free(*q);
3804
3805 free(d->engine->queue);
3806 }
3807
3808 free(d->engine);
3809 }
3810
3811 #ifdef WITH_LIBPERL
3812 if (d->perlfen)
3813 free(d->perlfen);
3814
3815 if (d->oldfen)
3816 free(d->oldfen);
3817 #endif
3818
3819 free(d);
3820 g->data = NULL;
3821 }
3822
3823 static void free_userdata()
3824 {
3825 int i;
3826
3827 for (i = 0; i < gtotal; i++) {
3828 free_userdata_once(game[i]);
3829 game[i]->data = NULL;
3830 }
3831 }
3832
3833 void update_loading_window(int n)
3834 {
3835 char buf[16];
3836
3837 if (!loadingw) {
3838 loadingw = newwin(3, COLS / 2, CALCPOSY(3), CALCPOSX(COLS / 2));
3839 loadingp = new_panel(loadingw);
3840 wbkgd(loadingw, CP_MESSAGE_WINDOW);
3841 }
3842
3843 wmove(loadingw, 0, 0);
3844 wclrtobot(loadingw);
3845 wattron(loadingw, CP_MESSAGE_BORDER);
3846 box(loadingw, ACS_VLINE, ACS_HLINE);
3847 wattroff(loadingw, CP_MESSAGE_BORDER);
3848 mvwprintw(loadingw, 1, CENTER_INT((COLS / 2), 11 +
3849 strlen(itoa(gtotal, buf))),
3850 _("Loading... %i%% (%i games)"), n, gtotal);
3851 update_panels();
3852 doupdate();
3853 }
3854
3855 static void init_userdata_once(GAME g, int n)
3856 {
3857 struct userdata_s *d = NULL;
3858
3859 d = Calloc(1, sizeof(struct userdata_s));
3860 d->n = n;
3861 d->c_row = 2, d->c_col = 5;
3862 SET_FLAG(d->flags, CF_NEW);
3863 g->data = d;
3864
3865 if (pgn_board_init_fen(g, d->b, NULL) != E_PGN_OK)
3866 pgn_board_init(d->b);
3867 }
3868
3869 void init_userdata()
3870 {
3871 int i;
3872
3873 for (i = 0; i < gtotal; i++)
3874 init_userdata_once(game[i], i);
3875 }
3876
3877 void fix_marks(int *start, int *end)
3878 {
3879 int i;
3880
3881 *start = (*start < 0) ? 0 : *start;
3882 *end = (*end < 0) ? 0 : *end;
3883
3884 if (*start > *end) {
3885 i = *start;
3886 *start = *end;
3887 *end = i + 1;
3888 }
3889
3890 *end = (*end > gtotal) ? gtotal : *end;
3891 }
3892
3893 void do_new_game_finalize(GAME g)
3894 {
3895 struct userdata_s *d = g->data;
3896
3897 d->mode = MODE_PLAY;
3898 update_status_notify(g, NULL);
3899 }
3900
3901 void do_new_game_from_scratch(WIN *win)
3902 {
3903 wchar_t str[] = { win->c, 0 };
3904
3905 if (wcscmp (str, yes_wchar))
3906 return;
3907
3908 stop_clock();
3909 free_userdata();
3910 pgn_parse(NULL);
3911 gp = game[gindex];
3912 add_custom_tags(&gp->tag);
3913 init_userdata();
3914 loadfile[0] = 0;
3915 do_new_game_finalize(gp);
3916 rotate = FALSE;
3917 }
3918
3919 void do_new_game()
3920 {
3921 pgn_new_game();
3922 gp = game[gindex];
3923 add_custom_tags(&gp->tag);
3924 init_userdata_once(gp, gindex);
3925 do_new_game_finalize(gp);
3926 rotate = FALSE;
3927 }
3928
3929 void do_game_delete_finalize(int n)
3930 {
3931 struct userdata_s *d;
3932
3933 delete_game((!n) ? gindex : -1);
3934 d = gp->data;
3935 pgn_board_update(gp, d->b, pgn_history_total(gp->hp));
3936 }
3937
3938 void do_game_delete_confirm(WIN *win)
3939 {
3940 int *n;
3941 wchar_t str[] = { win->c, 0 };
3942
3943 if (wcscmp (str, yes_wchar)) {
3944 free(win->data);
3945 return;
3946 }
3947
3948 n = (int *)win->data;
3949 do_game_delete_finalize(*n);
3950 free(win->data);
3951 }
3952
3953 void do_game_delete()
3954 {
3955 char *tmp = NULL;
3956 int i, n;
3957 struct userdata_s *d;
3958 int *p;
3959
3960 if (gtotal < 2) {
3961 cmessage(NULL, ANY_KEY_STR, "%s", _("Cannot delete last game."));
3962 return;
3963 }
3964
3965 tmp = NULL;
3966
3967 for (i = n = 0; i < gtotal; i++) {
3968 d = game[i]->data;
3969
3970 if (TEST_FLAG(d->flags, CF_DELETE))
3971 n++;
3972 }
3973
3974 if (!n)
3975 tmp = _("Delete the current game?");
3976 else {
3977 if (n == gtotal) {
3978 cmessage(NULL, ANY_KEY_STR, "%s", _("Cannot delete last game."));
3979 return;
3980 }
3981
3982 tmp = _("Delete all games marked for deletion?");
3983 }
3984
3985 if (config.deleteprompt) {
3986 p = Malloc(sizeof(int));
3987 *p = n;
3988 construct_message(NULL, _("[ Yes or No ]"), 1, 1, NULL, NULL, p,
3989 do_game_delete_confirm, 0, 0, tmp);
3990 return;
3991 }
3992
3993 do_game_delete_finalize(n);
3994 }
3995
3996 void do_find_game_exp_finalize(int which)
3997 {
3998 struct userdata_s *d = gp->data;
3999 int n;
4000
4001 if ((n = find_game_exp(gameexp, (which == -1) ? 0 : 1,
4002 (keycount) ? keycount : 1)) == -1) {
4003 update_status_notify(gp, "%s", _("No matches found"));
4004 return;
4005 }
4006
4007 gindex = n;
4008 d = gp->data;
4009
4010 if (pgn_history_total(gp->hp))
4011 d->mode = MODE_HISTORY;
4012
4013 pgn_board_update(gp, d->b, pgn_history_total(gp->hp));
4014 }
4015
4016 void do_find_game_exp(WIN *win)
4017 {
4018 struct input_data_s *in = win->data;
4019 int *n = in->data;
4020 int c = *n;
4021
4022 if (in->str) {
4023 strncpy(gameexp, in->str, sizeof(gameexp));
4024 gameexp[sizeof(gameexp)-1] = 0;
4025
4026 if (c == '?')
4027 c = '}';
4028
4029 do_find_game_exp_finalize(c);
4030 free(in->str);
4031 }
4032
4033 free(in->data);
4034 free(in);
4035 }
4036
4037 void do_game_jump_finalize(int n)
4038 {
4039 struct userdata_s *d;
4040
4041 if (--n > gtotal - 1 || n < 0)
4042 return;
4043
4044 gindex = n;
4045 gp = game[gindex];
4046 d = gp->data;
4047 pgn_board_update(gp, d->b, pgn_history_total(gp->hp));
4048 update_status_notify(gp, NULL);
4049 }
4050
4051 void do_game_jump(WIN *win)
4052 {
4053 struct input_data_s *in = win->data;
4054
4055 if (!in->str || !isinteger(in->str)) {
4056 if (in->str)
4057 free(in->str);
4058
4059 free(in);
4060 return;
4061 }
4062
4063 do_game_jump_finalize(atoi(in->str));
4064 free(in->str);
4065 free(in);
4066 }
4067
4068 void do_load_file(WIN *win)
4069 {
4070 struct input_data_s *in = win->data;
4071 char *tmp = in->str;
4072 struct userdata_s *d;
4073 PGN_FILE *pgn = NULL;
4074 int n;
4075
4076 if (!in->str) {
4077 free(in);
4078 return;
4079 }
4080
4081 if ((tmp = pathfix(tmp)) == NULL)
4082 goto done;
4083
4084 n = pgn_open(tmp, "r", &pgn);
4085
4086 if (n == E_PGN_ERR) {
4087 cmessage(ERROR_STR, ANY_KEY_STR, "%s\n%s", tmp, strerror(errno));
4088 goto done;
4089 }
4090 else if (n == E_PGN_INVALID) {
4091 cmessage(ERROR_STR, ANY_KEY_STR, "%s\n%s", tmp, _("Not a regular file"));
4092 goto done;
4093 }
4094
4095 free_userdata();
4096
4097 if (pgn_parse(pgn) == E_PGN_ERR) {
4098 del_panel(loadingp);
4099 delwin(loadingw);
4100 loadingw = NULL;
4101 loadingp = NULL;
4102 init_userdata();
4103 goto done;
4104 }
4105
4106 del_panel(loadingp);
4107 delwin(loadingw);
4108 loadingw = NULL;
4109 loadingp = NULL;
4110 init_userdata();
4111 strncpy(loadfile, tmp, sizeof(loadfile));
4112 loadfile[sizeof(loadfile)-1] = 0;
4113 gp = game[gindex];
4114 d = gp->data;
4115
4116 if (pgn_history_total(gp->hp))
4117 d->mode = MODE_HISTORY;
4118
4119 pgn_board_update(gp, d->b, pgn_history_total(gp->hp));
4120
4121 fm_loaded_file = TRUE;
4122
4123 done:
4124 pgn_close(pgn);
4125
4126 if (in->str)
4127 free(in->str);
4128
4129 free(in);
4130 }
4131
4132 void do_game_save(WIN *win)
4133 {
4134 struct input_data_s *in = win->data;
4135 int *x = in->data;
4136 int n = *x;
4137 char *tmp = in->str;
4138 char tfile[FILENAME_MAX];
4139 char *p;
4140 int i;
4141 struct userdata_s *d;
4142
4143 if (!tmp || (tmp = pathfix(tmp)) == NULL)
4144 goto done;
4145
4146 if (pgn_is_compressed(tmp) == E_PGN_ERR) {
4147 p = tmp + strlen(tmp) - 1;
4148
4149 if (*p != 'n' || *(p-1) != 'g' || *(p-2) != 'p' ||
4150 *(p-3) != '.') {
4151 snprintf(tfile, sizeof(tfile), "%s.pgn", tmp);
4152 tmp = tfile;
4153 }
4154 }
4155
4156 /*
4157 * When in edit mode, update the FEN tag.
4158 */
4159 if (n == -1) {
4160 for (i = 0; i < gtotal; i++) {
4161 d = game[i]->data;
4162
4163 if (d->mode == MODE_EDIT) {
4164 char *fen = pgn_game_to_fen(game[i], d->b);
4165
4166 pgn_tag_add(&game[i]->tag, "FEN", fen);
4167 free (fen);
4168 }
4169 }
4170 }
4171 else {
4172 d = game[n]->data;
4173
4174 if (d->mode == MODE_EDIT) {
4175 char *fen = pgn_game_to_fen(game[n], d->b);
4176
4177 pgn_tag_add(&game[n]->tag, "FEN", fen);
4178 free (fen);
4179 }
4180 }
4181
4182 save_pgn(tmp, n);
4183
4184 done:
4185 if (in->str)
4186 free(in->str);
4187
4188 free(in->data);
4189 free(in);
4190 }
4191
4192 void do_get_game_save_input(int n)
4193 {
4194 struct input_data_s *in = Calloc(1, sizeof(struct input_data_s));
4195 int *p = Malloc(sizeof(int));
4196
4197 in->efunc = do_game_save;
4198 *p = n;
4199 in->data = p;
4200
4201 construct_input(_("Save Game Filename"), loadfile, 1, 1, _("Type TAB for file browser"),
4202 file_browser, NULL, '\t', in, INPUT_HIST_FILE, -1);
4203 }
4204
4205 void do_game_save_multi_confirm(WIN *win)
4206 {
4207 int i;
4208 wchar_t str[] = { win->c, 0 };
4209
4210 if (!wcscmp (str, current_wchar))
4211 i = gindex;
4212 else if (!wcscmp (str, all_wchar))
4213 i = -1;
4214 else {
4215 update_status_notify(gp, "%s", _("Save game aborted."));
4216 return;
4217 }
4218
4219 do_get_game_save_input(i);
4220 }
4221
4222 void do_global_about()
4223 {
4224 cmessage("ABOUT", ANY_KEY_STR, "%s\nUsing %s with %i colors "
4225 "and %i color pairs\n%s",
4226 PACKAGE_STRING, curses_version(), COLORS, COLOR_PAIRS,
4227 COPYRIGHT);
4228 }
4229
4230 void global_game_next_prev(int which)
4231 {
4232 struct userdata_s *d;
4233
4234 game_next_prev(gp, (which == 1) ? 1 : 0,
4235 (keycount) ? keycount : 1);
4236 d = gp->data;
4237
4238 if (delete_count) {
4239 if (which == 1) {
4240 markend = markstart + delete_count;
4241 delete_count = 0;
4242 }
4243 else {
4244 markend = markstart - delete_count + 1;
4245 delete_count = -1; // to fix gindex in the other direction
4246 }
4247
4248 fix_marks(&markstart, &markend);
4249 do_global_toggle_delete();
4250 }
4251
4252 if (d->mode == MODE_HISTORY)
4253 pgn_board_update(gp, d->b, gp->hindex);
4254 else if (d->mode == MODE_PLAY)
4255 pgn_board_update(gp, d->b, pgn_history_total(gp->hp));
4256 }
4257
4258 void do_global_next_game()
4259 {
4260 global_game_next_prev(1);
4261 }
4262
4263 void do_global_prev_game()
4264 {
4265 global_game_next_prev(0);
4266 }
4267
4268 void global_find(int which)
4269 {
4270 struct input_data_s *in;
4271 int *p;
4272
4273 if (gtotal < 2)
4274 return;
4275
4276 in = Calloc(1, sizeof(struct input_data_s));
4277 p = Malloc(sizeof(int));
4278 *p = which;
4279 in->data = p;
4280 in->efunc = do_find_game_exp;
4281
4282 if (!*gameexp || which == 0) {
4283 construct_input(_("Find Game by Tag Expression"), NULL, 1, 0,
4284 _("[name expression:]value expression"), NULL, NULL, 0, in,
4285 INPUT_HIST_GAME_EXP, -1);
4286 return;
4287 }
4288
4289 do_find_game_exp_finalize(which);
4290 }
4291
4292 void do_global_find_new()
4293 {
4294 global_find(0);
4295 }
4296
4297 void do_global_find_next()
4298 {
4299 global_find(1);
4300 }
4301
4302 void do_global_find_prev()
4303 {
4304 global_find(-1);
4305 }
4306
4307 void do_global_game_jump()
4308 {
4309 if (gtotal < 2)
4310 return;
4311
4312 if (!keycount) {
4313 struct input_data_s *in;
4314
4315 in = Calloc(1, sizeof(struct input_data_s));
4316 in->efunc = do_game_jump;
4317 construct_input(_("Jump to Game Number"), NULL, 1, 1, NULL, NULL, NULL, 0, in,
4318 -1, 0);
4319 return;
4320 }
4321
4322 do_game_jump_finalize(keycount);
4323 }
4324
4325 void do_global_toggle_delete()
4326 {
4327 int i;
4328
4329 pushkey = 0;
4330
4331 if (gtotal < 2)
4332 return;
4333
4334 if (keycount && delete_count == 0) {
4335 markstart = gindex;
4336 delete_count = keycount;
4337 update_status_notify(gp, "%s (delete)", status.notify);
4338 return;
4339 }
4340
4341 if (markstart >= 0 && markend >= 0) {
4342 for (i = markstart; i < markend; i++) {
4343 if (toggle_delete_flag(i)) {
4344 return;
4345 }
4346 }
4347
4348 gindex = (delete_count < 0) ? markstart : i - 1;
4349 }
4350 else {
4351 if (toggle_delete_flag(gindex))
4352 return;
4353 }
4354
4355 markstart = markend = -1;
4356 delete_count = 0;
4357 update_status_window(gp);
4358 }
4359
4360 void do_global_delete_game()
4361 {
4362 do_game_delete();
4363 }
4364
4365 void do_global_tag_edit()
4366 {
4367 struct userdata_s *d = gp->data;
4368
4369 edit_tags(gp, d->b, 1);
4370 }
4371
4372 void do_global_tag_view()
4373 {
4374 struct userdata_s *d = gp->data;
4375
4376 edit_tags(gp, d->b, 0);
4377 }
4378
4379 void do_global_resume_game()
4380 {
4381 struct input_data_s *in;
4382
4383 in = Calloc(1, sizeof(struct input_data_s));
4384 in->efunc = do_load_file;
4385 construct_input(_("Load Filename"), NULL, 1, 1, _("Type TAB for file browser"), file_browser,
4386 NULL, '\t', in, INPUT_HIST_FILE, -1);
4387 }
4388
4389 void do_global_save_game()
4390 {
4391 if (gtotal > 1) {
4392 construct_message(NULL, _("What would you like to do?"), 0, 1,
4393 NULL, NULL, NULL, do_game_save_multi_confirm, 0, 0,
4394 _("There is more than one game loaded. Press \"%ls\" to save the current game, \"%ls\" to save all games or any other key to cancel."),
4395 current_wchar, all_wchar);
4396 return;
4397 }
4398
4399 do_get_game_save_input(-1);
4400 }
4401
4402 void do_global_new_game()
4403 {
4404 do_new_game();
4405 }
4406
4407 void do_global_copy_game()
4408 {
4409 int g = gindex;
4410 int i, n;
4411 struct userdata_s *d;
4412
4413 do_global_new_game();
4414 d = gp->data;
4415 n = pgn_tag_total(game[g]->tag);
4416
4417 for (i = 0; i < n; i++)
4418 pgn_tag_add(&gp->tag, game[g]->tag[i]->name,
4419 game[g]->tag[i]->value);
4420
4421 pgn_board_init_fen (gp, d->b, NULL);
4422 n = pgn_history_total(game[g]->history);
4423
4424 // FIXME RAV
4425 for (i = 0; i < n; i++) {
4426 char *frfr = NULL;
4427 char move[MAX_SAN_MOVE_LEN+1] = {0}, *m = move;
4428
4429 strcpy (move, game[g]->history[i]->move);
4430 if (pgn_parse_move(gp, d->b, &m, &frfr) != E_PGN_OK) {
4431 SET_FLAG(gp->flags, GF_PERROR);
4432 return;
4433 }
4434
4435 pgn_history_add(gp, d->b, move);
4436 free(frfr);
4437 pgn_switch_turn(gp);
4438 }
4439
4440 pgn_board_update(gp, d->b, pgn_history_total(gp->hp));
4441 }
4442
4443 void do_global_new_all()
4444 {
4445 construct_message(NULL, _("[ Yes or No ]"), 1, 1, NULL, NULL, NULL,
4446 do_new_game_from_scratch, 0, 0, "%s", _("Really start a new game from scratch?"));
4447 }
4448
4449 void do_quit(WIN *win)
4450 {
4451 wchar_t str[] = { win->c, 0 };
4452
4453 if (wcscmp (str, yes_wchar))
4454 return;
4455
4456 quit = 1;
4457 }
4458
4459 void do_global_quit()
4460 {
4461 if (config.exitdialogbox)
4462 construct_message(NULL, _("[ Yes or No ]"), 1, 1, NULL, NULL, NULL,
4463 do_quit, 0, 0, _("Want to Quit?"));
4464 else
4465 quit = 1;
4466 }
4467
4468 void do_global_toggle_engine_window()
4469 {
4470 if (!enginew) {
4471 enginew = newwin(LINES, COLS, 0, 0);
4472 enginep = new_panel(enginew);
4473 window_draw_title(enginew, _("Engine IO Window"), COLS, CP_MESSAGE_TITLE,
4474 CP_MESSAGE_BORDER);
4475 hide_panel(enginep);
4476 }
4477
4478 if (panel_hidden(enginep)) {
4479 update_engine_window(gp);
4480 top_panel(enginep);
4481 }
4482 else {
4483 hide_panel(enginep);
4484 }
4485 }
4486
4487 void do_global_toggle_board_details()
4488 {
4489 do_board_details();
4490 }
4491
4492 void do_global_toggle_strict_castling()
4493 {
4494 do_toggle_strict_castling();
4495 }
4496
4497 // Global and other keys.
4498 static int globalkeys()
4499 {
4500 struct userdata_s *d = gp->data;
4501 int i;
4502
4503 /*
4504 * These cannot be modified and other game mode keys cannot conflict with
4505 * these.
4506 */
4507 switch (input_c) {
4508 case CTRL_KEY('L'):
4509 do_window_resize ();
4510 return 1;
4511 case KEY_ESCAPE:
4512 d->sp.icon = d->sp.srow = d->sp.scol = 0;
4513 markend = markstart = 0;
4514
4515 if (keycount) {
4516 keycount = 0;
4517 update_status_notify(gp, NULL);
4518 }
4519
4520 if (config.validmoves)
4521 pgn_reset_valid_moves(d->b);
4522
4523 return 1;
4524 case '0' ... '9':
4525 i = input_c - '0';
4526
4527 if (keycount)
4528 keycount = keycount * 10 + i;
4529 else
4530 keycount = i;
4531
4532 update_status_notify(gp, _("Repeat %i"), keycount);
4533 return -1;
4534 case KEY_UP:
4535 if (d->mode == MODE_HISTORY)
4536 return 0;
4537
4538 if (keycount)
4539 d->c_row += keycount;
4540 else
4541 d->c_row++;
4542
4543 if (d->c_row > 8)
4544 d->c_row = 1;
4545
4546 return 1;
4547 case KEY_DOWN:
4548 if (d->mode == MODE_HISTORY)
4549 return 0;
4550
4551 if (keycount) {
4552 d->c_row -= keycount;
4553 update_status_notify(gp, NULL);
4554 }
4555 else
4556 d->c_row--;
4557
4558 if (d->c_row < 1)
4559 d->c_row = 8;
4560
4561 return 1;
4562 case KEY_LEFT:
4563 if (d->mode == MODE_HISTORY)
4564 return 0;
4565
4566 if (keycount)
4567 d->c_col -= keycount;
4568 else
4569 d->c_col--;
4570
4571 if (d->c_col < 1)
4572 d->c_col = 8;
4573
4574 return 1;
4575 case KEY_RIGHT:
4576 if (d->mode == MODE_HISTORY)
4577 return 0;
4578
4579 if (keycount)
4580 d->c_col += keycount;
4581 else
4582 d->c_col++;
4583
4584 if (d->c_col > 8)
4585 d->c_col = 1;
4586
4587 return 1;
4588 case KEY_RESIZE:
4589 return 1;
4590 case 0:
4591 default:
4592 for (i = 0; global_keys[i]; i++) {
4593 if (input_c == global_keys[i]->c) {
4594 (*global_keys[i]->f)();
4595 return 1;
4596 }
4597 }
4598 break;
4599 }
4600
4601 return 0;
4602 }
4603
4604 #ifdef WITH_LIBPERL
4605 static void perl_error(const char *fmt, ...)
4606 {
4607 va_list ap;
4608 char *buf;
4609
4610 va_start(ap, fmt);
4611 vasprintf(&buf, fmt, ap);
4612 va_end(ap);
4613
4614 message(ERROR_STR, ANY_KEY_STR, "%s", buf);
4615 free(buf);
4616 }
4617
4618 static void do_perl_finalize(WIN *win)
4619 {
4620 struct input_data_s *in = win->data;
4621 GAME g = in->data;
4622 struct userdata_s *d = g->data;
4623 char *filename;
4624 char *result = NULL;
4625 char *arg = NULL;
4626 int n;
4627
4628 asprintf(&filename, "%s/perl.pl", config.datadir);
4629
4630 if (!in->str)
4631 goto done;
4632
4633 if (perl_init_file(filename, perl_error))
4634 goto done;
4635
4636 arg = pgn_game_to_fen(g, d->b);
4637
4638 if (perl_call_sub(trim(in->str), arg, &result))
4639 goto done;
4640
4641 d->perlfen = pgn_game_to_fen(g, d->b);
4642 d->perlflags = g->flags;
4643
4644 if (pgn_board_init_fen(g, d->b, result) != E_PGN_OK) {
4645 message(ERROR_STR, ANY_KEY_STR, "%s", _("FEN parse error."));
4646 pgn_board_init_fen(g, d->b, d->perlfen);
4647 g->flags = d->perlflags;
4648 free(d->perlfen);
4649 d->perlfen = NULL;
4650 goto done;
4651 }
4652
4653 SET_FLAG(d->flags, CF_PERL);
4654 n = pgn_tag_find(g->tag, "FEN");
4655
4656 if (n != E_PGN_ERR)
4657 d->oldfen = strdup(g->tag[n]->value);
4658
4659 pgn_tag_add(&g->tag, "FEN", result);
4660 update_status_notify(g, "%s", ANY_KEY_STR);
4661 update_all(g);
4662
4663 done:
4664 free(result);
4665 free(arg);
4666 free(in->str);
4667 free(in);
4668 free(filename);
4669 }
4670
4671 void do_global_perl()
4672 {
4673 struct input_data_s *in;
4674
4675 in = Calloc(1, sizeof(struct input_data_s));
4676 in->data = gp;
4677 in->efunc = do_perl_finalize;
4678 construct_input(_("PERL Subroutine Filter"), NULL, 1, 0, NULL, NULL, NULL, 0, in, INPUT_HIST_PERL, -1);
4679 }
4680 #endif
4681
4682 /*
4683 * A macro may contain a key that belongs to another macro so macro_match will
4684 * need to be updated to the new index of the matching macro.
4685 */
4686 static void find_macro(struct userdata_s *d)
4687 {
4688 int i;
4689
4690 /*
4691 * Macros can't contain macros when in a window.
4692 */
4693 if (wins)
4694 return;
4695
4696 again:
4697 for (i = 0; macros[i]; i++) {
4698 if ((macros[i]->mode == -1 || macros[i]->mode == d->mode) &&
4699 input_c == macros[i]->c) {
4700 input_c = macros[i]->keys[macros[i]->n++];
4701
4702 if (!macro_depth_n && macro_match > -1) {
4703 macro_depth = realloc(macro_depth, (macro_depth_n + 1) * sizeof(int));
4704 macro_depth[macro_depth_n++] = macro_match;
4705 }
4706
4707 macro_depth = realloc(macro_depth, (macro_depth_n + 1) * sizeof(int));
4708 macro_depth[macro_depth_n++] = i;
4709 macro_match = i;
4710 goto again;
4711 }
4712 }
4713 }
4714
4715 /*
4716 * Resets the position in each macro to the first key.
4717 */
4718 static void reset_macros()
4719 {
4720 int i;
4721 struct userdata_s *d = gp->data;
4722
4723 again:
4724 if (macro_depth_n > 0) {
4725 macro_depth_n--;
4726 macro_match = macro_depth[macro_depth_n];
4727
4728 if (macros[macro_match]->n >= macros[macro_match]->total)
4729 goto again;
4730
4731 input_c = macros[macro_match]->keys[macros[macro_match]->n++];
4732 find_macro(d);
4733 return;
4734 }
4735
4736 for (i = 0; macros[i]; i++)
4737 macros[i]->n = 0;
4738
4739 free(macro_depth);
4740 macro_depth = NULL;
4741 macro_depth_n = 0;
4742 macro_match = -1;
4743 }
4744
4745 void game_loop()
4746 {
4747 struct userdata_s *d;
4748
4749 macro_match = -1;
4750 gindex = gtotal - 1;
4751 gp = game[gindex];
4752 d = gp->data;
4753
4754 if (pgn_history_total(gp->hp))
4755 d->mode = MODE_HISTORY;
4756 else {
4757 d->mode = MODE_PLAY;
4758 d->play_mode = PLAY_HE;
4759 }
4760
4761 if (d->mode == MODE_HISTORY)
4762 pgn_board_update(gp, d->b, pgn_history_total(gp->hp));
4763
4764 update_status_notify(gp, "%s", _("Type F1 for help"));
4765 movestep = 2;
4766 flushinp();
4767 update_all(gp);
4768 wtimeout(boardw, WINDOW_TIMEOUT);
4769
4770 while (!quit) {
4771 int n = 0, i;
4772 char fdbuf[8192] = {0};
4773 int len;
4774 struct timeval tv = {0, 0};
4775 fd_set rfds, wfds;
4776 WIN *win = NULL;
4777 WINDOW *wp = NULL;
4778
4779 FD_ZERO(&rfds);
4780 FD_ZERO(&wfds);
4781
4782 for (i = 0; i < gtotal; i++) {
4783 d = game[i]->data;
4784
4785 if (d->engine && d->engine->pid != -1) {
4786 if (d->engine->fd[ENGINE_IN_FD] > 2) {
4787 if (d->engine->fd[ENGINE_IN_FD] > n)
4788 n = d->engine->fd[ENGINE_IN_FD];
4789
4790 FD_SET(d->engine->fd[ENGINE_IN_FD], &rfds);
4791 }
4792
4793 if (d->engine->fd[ENGINE_OUT_FD] > 2) {
4794 if (d->engine->fd[ENGINE_OUT_FD] > n)
4795 n = d->engine->fd[ENGINE_OUT_FD];
4796
4797 FD_SET(d->engine->fd[ENGINE_OUT_FD], &wfds);
4798 }
4799 }
4800 }
4801
4802 if (n) {
4803 if ((n = select(n + 1, &rfds, &wfds, NULL, &tv)) > 0) {
4804 for (i = 0; i < gtotal; i++) {
4805 d = game[i]->data;
4806
4807 if (d->engine && d->engine->pid != -1) {
4808 if (FD_ISSET(d->engine->fd[ENGINE_IN_FD], &rfds)) {
4809 len = read(d->engine->fd[ENGINE_IN_FD], fdbuf,
4810 sizeof(fdbuf));
4811
4812 if (len > 0) {
4813 if (d->engine->iobuf)
4814 d->engine->iobuf = Realloc(d->engine->iobuf, d->engine->len + len + 1);
4815 else
4816 d->engine->iobuf = Calloc(1, len + 1);
4817
4818 memcpy(&(d->engine->iobuf[d->engine->len]), &fdbuf, len);
4819 d->engine->len += len;
4820 d->engine->iobuf[d->engine->len] = 0;
4821
4822 /*
4823 * The fdbuf is full or no newline
4824 * was found. So we'll append the next
4825 * read() to this games buffer.
4826 */
4827 if (d->engine->iobuf[d->engine->len - 1] != '\n')
4828 continue;
4829
4830 parse_engine_output(game[i], d->engine->iobuf);
4831 free(d->engine->iobuf);
4832 d->engine->iobuf = NULL;
4833 d->engine->len = 0;
4834 }
4835 else if (len == -1) {
4836 if (errno != EAGAIN) {
4837 cmessage(ERROR_STR, ANY_KEY_STR, "Engine read(): %s",
4838 strerror(errno));
4839 waitpid(d->engine->pid, &n, 0);
4840 free(d->engine);
4841 d->engine = NULL;
4842 break;
4843 }
4844 }
4845 }
4846
4847 if (FD_ISSET(d->engine->fd[ENGINE_OUT_FD], &wfds)) {
4848 if (d->engine->queue)
4849 send_engine_command(game[i]);
4850 }
4851 }
4852 }
4853 }
4854 else {
4855 if (n == -1)
4856 cmessage(ERROR_STR, ANY_KEY_STR, "select(): %s", strerror(errno));
4857 /* timeout */
4858 }
4859 }
4860
4861 gp = game[gindex];
4862 d = gp->data;
4863
4864 /*
4865 * This is needed to detect terminal resizing.
4866 */
4867 doupdate();
4868 if (LINES != LINES_OLD || COLS != COLS_OLD) {
4869 COLS_OLD = COLS;
4870 LINES_OLD = LINES;
4871 do_window_resize();
4872 }
4873
4874 /*
4875 * Finds the top level window in the window stack so we know what
4876 * window the wget_wch()'ed key belongs to.
4877 */
4878 if (wins) {
4879 for (i = 0; wins[i]; i++);
4880 win = wins[i-1];
4881 wp = win->w;
4882 wtimeout(wp, WINDOW_TIMEOUT);
4883 }
4884 else
4885 wp = boardw;
4886
4887 if (!i && pushkey)
4888 input_c = pushkey;
4889 else {
4890 if (!pushkey) {
4891 if (macros && macro_match >= 0) {
4892 if (macros[macro_match]->n >= macros[macro_match]->total)
4893 reset_macros();
4894 else {
4895 input_c = macros[macro_match]->keys[macros[macro_match]->n++];
4896 find_macro(d);
4897 }
4898 }
4899 else {
4900 if (wget_wch(wp, &input_c) == ERR || input_c == KEY_RESIZE)
4901 continue;
4902 }
4903 }
4904 else
4905 input_c = pushkey;
4906
4907 if (win) {
4908 switch (input_c) {
4909 case CTRL_KEY('L'):
4910 do_window_resize ();
4911 goto refresh;
4912 }
4913
4914 win->c = input_c;
4915
4916 /*
4917 * Run the function associated with the window. When the
4918 * function returns 0 win->efunc is ran (if not NULL) with
4919 * win as the one and only parameter. Then the window is
4920 * destroyed.
4921 *
4922 * The exit function may create another window which will
4923 * mess up the window stack when window_destroy() is called.
4924 * So don't destory the window until the top window is
4925 * destroyable. See window_destroy().
4926 */
4927 if ((*win->func)(win) == 0) {
4928 if (win->efunc)
4929 (*win->efunc)(win);
4930
4931 win->keep = 1;
4932 window_destroy(win);
4933 update_all(gp);
4934 }
4935
4936 continue;
4937 }
4938 }
4939
4940 if (!keycount && status.notify)
4941 update_status_notify(gp, NULL);
4942
4943 #ifdef WITH_LIBPERL
4944 if (TEST_FLAG(d->flags, CF_PERL)) {
4945 CLEAR_FLAG(d->flags, CF_PERL);
4946 pgn_board_init_fen(gp, d->b, d->perlfen);
4947 gp->flags = d->perlflags;
4948 free(d->perlfen);
4949 pgn_tag_add(&gp->tag, "FEN", d->oldfen);
4950 free(d->oldfen);
4951 d->perlfen = d->oldfen = NULL;
4952 update_all(gp);
4953 continue;
4954 }
4955 #endif
4956
4957 if (macros && macro_match < 0)
4958 find_macro(d);
4959
4960 if ((n = globalkeys()) == 1) {
4961 if (macro_match == -1)
4962 keycount = 0;
4963
4964 goto refresh;
4965 }
4966 else if (n == -1)
4967 goto refresh;
4968
4969 switch (d->mode) {
4970 case MODE_EDIT:
4971 for (i = 0; edit_keys[i]; i++) {
4972 if (input_c == edit_keys[i]->c) {
4973 (*edit_keys[i]->f)();
4974 break;
4975 }
4976 }
4977 break;
4978 case MODE_PLAY:
4979 for (i = 0; play_keys[i]; i++) {
4980 if (input_c == play_keys[i]->c) {
4981 (*play_keys[i]->f)();
4982 goto done;
4983 }
4984 }
4985
4986 do_play_config_command();
4987 break;
4988 case MODE_HISTORY:
4989 for (i = 0; history_keys[i]; i++) {
4990 if (input_c == history_keys[i]->c) {
4991 (*history_keys[i]->f)();
4992 break;
4993 }
4994 }
4995 break;
4996 default:
4997 break;
4998 }
4999
5000 done:
5001 if (keycount)
5002 update_status_notify(gp, NULL);
5003
5004 keycount = 0;
5005
5006 refresh:
5007 update_all(gp);
5008 }
5009 }
5010
5011 void usage(const char *pn, int ret)
5012 {
5013 fprintf((ret) ? stderr : stdout, "%s%s",
5014 #ifdef DEBUG
5015 _(
5016 "Usage: cboard [-hvCD] [-u [N]] [-p [-VtRSE] <file>]\n"
5017 " -D Dump libchess debugging info to \"libchess.debug\" (stderr)\n"),
5018 #else
5019 _(
5020 "Usage: cboard [-hvC] [-u [N]] [-p [-VtRSE] <file>]\n"),
5021 #endif
5022 _(
5023 " -p Load PGN file.\n"
5024 " -V Validate a game file.\n"
5025 " -S Validate and output a PGN formatted game.\n"
5026 " -R Like -S but write a reduced PGN formatted game.\n"
5027 " -t Also write custom PGN tags from config file.\n"
5028 " -E Stop processing on file parsing error (overrides config).\n"
5029 " -C Enable strict castling (overrides config).\n"
5030 " -u Enable/disable UTF-8 pieces (1=enable, 0=disable, overrides config).\n"
5031 " -v Version information.\n"
5032 " -h This help text.\n"));
5033
5034 exit(ret);
5035 }
5036
5037 void cleanup_all()
5038 {
5039 int i;
5040
5041 stop_clock();
5042 free_userdata();
5043 pgn_free_all();
5044 free(config.engine_cmd);
5045 free(config.pattern);
5046 free(config.ccfile);
5047 free(config.nagfile);
5048 free(config.configfile);
5049
5050 if (config.keys) {
5051 for (i = 0; config.keys[i]; i++) {
5052 free(config.keys[i]->str);
5053 free(config.keys[i]);
5054 }
5055
5056 free(config.keys);
5057 }
5058
5059 if (config.einit) {
5060 for (i = 0; config.einit[i]; i++)
5061 free(config.einit[i]);
5062
5063 free(config.einit);
5064 }
5065
5066 if (config.tag)
5067 pgn_tag_free(config.tag);
5068
5069 free(config.datadir);
5070
5071 if (curses_initialized) {
5072 del_panel(boardp);
5073 del_panel(historyp);
5074 del_panel(statusp);
5075 del_panel(tagp);
5076 delwin(boardw);
5077 delwin(historyw);
5078 delwin(statusw);
5079 delwin(tagw);
5080
5081 if (enginew) {
5082 del_panel(enginep);
5083 delwin(enginew);
5084 }
5085
5086 endwin();
5087 }
5088
5089 #ifdef WITH_LIBPERL
5090 perl_cleanup();
5091 #endif
5092 }
5093
5094 static void signal_save_pgn(int sig)
5095 {
5096 char *buf;
5097 time_t now;
5098 char *p = config.savedirectory ? config.savedirectory : config.datadir;
5099
5100 time(&now);
5101 asprintf(&buf, "%s/signal-%i-%li.pgn", p, sig, now);
5102
5103 if (do_game_write(buf, "w", 0, gtotal)) {
5104 cmessage(ERROR_STR, ANY_KEY_STR, "%s: %s", p, strerror(errno));
5105 update_status_notify(gp, "%s", _("Save game failed."));
5106 }
5107
5108 free(buf);
5109 quit = 1;
5110 }
5111
5112 void catch_signal(int which)
5113 {
5114 switch (which) {
5115 case SIGALRM:
5116 update_clocks();
5117 break;
5118 case SIGPIPE:
5119 if (which == SIGPIPE && quit)
5120 break;
5121
5122 if (which == SIGPIPE)
5123 cmessage(NULL, ANY_KEY_STR, "%s", _("Broken pipe. Quitting."));
5124
5125 cleanup_all();
5126 exit(EXIT_FAILURE);
5127 break;
5128 case SIGSTOP:
5129 savetty();
5130 break;
5131 case SIGCONT:
5132 resetty();
5133 do_window_resize ();
5134 keypad(boardw, TRUE);
5135 break;
5136 case SIGINT:
5137 quit = 1;
5138 break;
5139 case SIGTERM:
5140 signal_save_pgn(which);
5141 break;
5142 default:
5143 break;
5144 }
5145 }
5146
5147 void loading_progress(long total, long offset)
5148 {
5149 int n = (100 * (offset / 100) / (total / 100));
5150
5151 if (curses_initialized)
5152 update_loading_window(n);
5153 else {
5154 fprintf(stderr, _("Loading... %i%% (%i games)%c"), n, gtotal, '\r');
5155 fflush(stderr);
5156 }
5157 }
5158
5159 static void set_defaults()
5160 {
5161 set_config_defaults();
5162 set_default_keys();
5163 filetype = FILE_NONE;
5164 pgn_config_set(PGN_PROGRESS, 1024);
5165 pgn_config_set(PGN_PROGRESS_FUNC, loading_progress);
5166 }
5167
5168 int main(int argc, char *argv[])
5169 {
5170 int opt;
5171 struct stat st;
5172 char buf[FILENAME_MAX];
5173 char datadir[FILENAME_MAX];
5174 int ret = EXIT_SUCCESS;
5175 int validate_only = 0, validate_and_write = 0;
5176 int write_custom_tags = 0;
5177 int i = 0;
5178 PGN_FILE *pgn;
5179 int utf8_pieces = -1;
5180
5181 setlocale (LC_ALL, "");
5182 bindtextdomain ("cboard", LOCALE_DIR);
5183 textdomain ("cboard");
5184
5185 /* Solaris 5.9 */
5186 #ifndef HAVE_PROGNAME
5187 __progname = argv[0];
5188 #endif
5189
5190 if ((config.pwd = getpwuid(getuid())) == NULL)
5191 err(EXIT_FAILURE, "getpwuid()");
5192
5193 snprintf(datadir, sizeof(datadir), "%s/.cboard", config.pwd->pw_dir);
5194 config.datadir = strdup(datadir);
5195 snprintf(buf, sizeof(buf), "%s/cc.data", datadir);
5196 config.ccfile = strdup(buf);
5197 snprintf(buf, sizeof(buf), "%s/nag.data", datadir);
5198 config.nagfile = strdup(buf);
5199 snprintf(buf, sizeof(buf), "%s/config", datadir);
5200 config.configfile = strdup(buf);
5201
5202 if (stat(datadir, &st) == -1) {
5203 if (errno == ENOENT) {
5204 if (mkdir(datadir, 0755) == -1)
5205 err(EXIT_FAILURE, "%s", datadir);
5206 }
5207 else
5208 err(EXIT_FAILURE, "%s", datadir);
5209
5210 stat(datadir, &st);
5211 }
5212
5213 if (!S_ISDIR(st.st_mode))
5214 errx(EXIT_FAILURE, "%s: %s", datadir, _("Not a directory."));
5215
5216 set_defaults();
5217
5218 #ifdef DEBUG
5219 while ((opt = getopt(argc, argv, "DCEVtSRhp:vu::")) != -1) {
5220 #else
5221 while ((opt = getopt(argc, argv, "ECVtSRhp:vu::")) != -1) {
5222 #endif
5223 switch (opt) {
5224 #ifdef DEBUG
5225 case 'D':
5226 unlink("libchess.debug");
5227 pgn_config_set(PGN_DEBUG, 1);
5228 break;
5229 #endif
5230 case 'C':
5231 pgn_config_set(PGN_STRICT_CASTLING, 1);
5232 break;
5233 case 't':
5234 write_custom_tags = 1;
5235 break;
5236 case 'E':
5237 i = 1;
5238 break;
5239 case 'R':
5240 pgn_config_set(PGN_REDUCED, 1);
5241 case 'S':
5242 validate_and_write = 1;
5243 case 'V':
5244 validate_only = 1;
5245 break;
5246 case 'v':
5247 printf("%s (%s)\n%s\n", PACKAGE_STRING, curses_version(),
5248 COPYRIGHT);
5249 exit(EXIT_SUCCESS);
5250 case 'p':
5251 filetype = FILE_PGN;
5252 strncpy(loadfile, optarg, sizeof(loadfile));
5253 loadfile[sizeof(loadfile)-1] = 0;
5254 break;
5255 case 'u':
5256 utf8_pieces = optarg ? atoi (optarg): 1;
5257 break;
5258 case 'h':
5259 default:
5260 usage(argv[0], EXIT_SUCCESS);
5261 }
5262 }
5263
5264 if ((validate_only || validate_and_write) && !*loadfile)
5265 usage(argv[0], EXIT_FAILURE);
5266
5267 if (access(config.configfile, R_OK) == 0)
5268 parse_rcfile(config.configfile);
5269
5270 if (i)
5271 pgn_config_set(PGN_STOP_ON_ERROR, 1);
5272
5273 signal(SIGPIPE, catch_signal);
5274 signal(SIGCONT, catch_signal);
5275 signal(SIGSTOP, catch_signal);
5276 signal(SIGINT, catch_signal);
5277 signal(SIGALRM, catch_signal);
5278 signal(SIGTERM, catch_signal);
5279
5280 srandom(getpid());
5281
5282 switch (filetype) {
5283 case FILE_PGN:
5284 if (pgn_open(loadfile, "r", &pgn) != E_PGN_OK)
5285 err(EXIT_FAILURE, "%s", loadfile);
5286
5287 ret = pgn_parse(pgn);
5288 pgn_close(pgn);
5289 break;
5290 case FILE_FEN:
5291 //ret = parse_fen_file(loadfile);
5292 break;
5293 case FILE_EPD: // Not implemented.
5294 case FILE_NONE:
5295 default:
5296 // No file specified. Empty game.
5297 ret = pgn_parse(NULL);
5298 gp = game[gindex];
5299 add_custom_tags(&gp->tag);
5300 break;
5301 }
5302
5303 if (validate_only || validate_and_write) {
5304 if (validate_and_write) {
5305 if (pgn_open("-", "r", &pgn) != E_PGN_OK)
5306 err(EXIT_FAILURE, "pgn_open()");
5307
5308 for (i = 0; i < gtotal; i++) {
5309 if (write_custom_tags)
5310 add_custom_tags(&game[i]->tag);
5311
5312 pgn_write(pgn, game[i]);
5313 }
5314
5315 pgn_close(pgn);
5316
5317 fm_loaded_file = TRUE;
5318 }
5319
5320 cleanup_all();
5321 exit(ret);
5322 }
5323 else if (ret == E_PGN_ERR)
5324 exit(ret);
5325
5326 if (utf8_pieces != -1)
5327 config.utf8_pieces = utf8_pieces;
5328
5329 init_wchar_pieces ();
5330 yes_wchar = str_to_wchar (_("y"));
5331 all_wchar = str_to_wchar (_("a"));
5332 overwrite_wchar = str_to_wchar (_("o"));
5333 resume_wchar = str_to_wchar (_("r"));
5334 current_wchar = str_to_wchar (_("c"));
5335 append_wchar = str_to_wchar (_("a"));
5336 translatable_tag_names[0] = _("Event");
5337 translatable_tag_names[1] = _("Site");
5338 translatable_tag_names[2] = _("Date");
5339 translatable_tag_names[3] = _("Round");
5340 translatable_tag_names[4] = _("White");
5341 translatable_tag_names[5] = _("Black");
5342 translatable_tag_names[6] = _("Result");
5343 init_userdata();
5344
5345 /*
5346 * This fixes window resizing in an xterm.
5347 */
5348 if (getenv("DISPLAY") != NULL) {
5349 putenv("LINES=");
5350 putenv("COLUMNS=");
5351 }
5352
5353 if (initscr() == NULL)
5354 errx(EXIT_FAILURE, "%s", _("Could not initialize curses."));
5355 else
5356 curses_initialized = 1;
5357
5358 if (LINES < 23 || COLS < 74) {
5359 endwin();
5360 errx(EXIT_FAILURE, _("Need at least an 74x23 terminal."));
5361 }
5362
5363 COLS_OLD = COLS;
5364 LINES_OLD = LINES;
5365
5366 if (has_colors() == TRUE && start_color() == OK)
5367 init_color_pairs();
5368
5369 boardw = newwin(BOARD_HEIGHT, BOARD_WIDTH, 0, COLS - BOARD_WIDTH);
5370 boardp = new_panel(boardw);
5371 historyw = newwin(HISTORY_HEIGHT, HISTORY_WIDTH, LINES - HISTORY_HEIGHT,
5372 COLS - HISTORY_WIDTH);
5373 historyp = new_panel(historyw);
5374 statusw = newwin(STATUS_HEIGHT, STATUS_WIDTH, 0, 0);
5375 statusp = new_panel(statusw);
5376 tagw = newwin(TAG_HEIGHT, TAG_WIDTH, STATUS_HEIGHT + 1, 0);
5377 tagp = new_panel(tagw);
5378 keypad(boardw, TRUE);
5379 // leaveok(boardw, TRUE);
5380 leaveok(tagw, TRUE);
5381 leaveok(statusw, TRUE);
5382 leaveok(historyw, TRUE);
5383 curs_set(0);
5384 cbreak();
5385 noecho();
5386 draw_window_decor();
5387 game_loop();
5388 cleanup_all();
5389 free (w_pawn_wchar);
5390 free (w_rook_wchar);
5391 free (w_bishop_wchar);
5392 free (w_knight_wchar);
5393 free (w_queen_wchar);
5394 free (w_king_wchar);
5395 free (b_pawn_wchar);
5396 free (b_rook_wchar);
5397 free (b_bishop_wchar);
5398 free (b_knight_wchar);
5399 free (b_queen_wchar);
5400 free (b_king_wchar);
5401 free (empty_wchar);
5402 free (enpassant_wchar);
5403 free (yes_wchar);
5404 free (all_wchar);
5405 free (overwrite_wchar);
5406 free (resume_wchar);
5407 free (current_wchar);
5408 free (append_wchar);
5409 exit(EXIT_SUCCESS);
5410 }
A console/ncurses chess engine frontend and PGN editor.