gnushogi/cursesdsp.c

   1 /*
   2  * FILE: cursesdsp.c
   3  *
   4  *     Curses interface for GNU Shogi
   5  *
   6  * ----------------------------------------------------------------------
   7  * Copyright (c) 1993, 1994, 1995 Matthias Mutz
   8  * Copyright (c) 1999 Michael Vanier and the Free Software Foundation
   9  * Copyright (c) 2008, 2013, 2014 Yann Dirson and the Free Software Foundation
  10  *
  11  * GNU SHOGI is based on GNU CHESS
  12  *
  13  * Copyright (c) 1988, 1989, 1990 John Stanback
  14  * Copyright (c) 1992 Free Software Foundation
  15  *
  16  * This file is part of GNU SHOGI.
  17  *
  18  * GNU Shogi is free software; you can redistribute it and/or modify it
  19  * under the terms of the GNU General Public License as published by the
  20  * Free Software Foundation; either version 3 of the License,
  21  * or (at your option) any later version.
  22  *
  23  * GNU Shogi is distributed in the hope that it will be useful, but WITHOUT
  24  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  25  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  26  * for more details.
  27  *
  28  * You should have received a copy of the GNU General Public License along
  29  * with GNU Shogi; see the file COPYING. If not, see
  30  * <http://www.gnu.org/licenses/>.
  31  * ----------------------------------------------------------------------
  32  */
  33
  34 /* request *snprintf prototypes*/
  35 #define _POSIX_C_SOURCE 200112L
  36
  37 #include <ctype.h>
  38 #include <signal.h>
  39 #include <stdio.h>
  40 #include <stdarg.h>
  41
  42 #include <sys/param.h>
  43 #include <sys/types.h>
  44 #include <sys/file.h>
  45 #include <curses.h>
  46
  47 #include "gnushogi.h"
  48
  49 #if HAVE_UNISTD_H
  50 #include <unistd.h>
  51 #endif
  52
  53 #if HAVE_SYS_FILIO_H
  54 /* Definition of FIONREAD */
  55 #include <sys/filio.h>
  56 #endif
  57
  58 #if HAVE_ERRNO_H
  59 /* Definition of errno(). */
  60 #include <errno.h>
  61 #endif
  62
  63 #define FLUSH_SCANW fflush(stdout), scanw
  64
  65 int mycnt1, mycnt2;
  66
  67 #define TAB (58)
  68
  69 #define VIR_C(s)  ((flag.reverse) ? (NO_COLS - 1 - column(s)) : column(s))
  70 #define VIR_R(s)  ((flag.reverse) ? (NO_ROWS - 1 - row(s)) : row(s))
  71
  72 char *DRAW;
  73
  74 /****************************************
  75  * forward declarations
  76  ****************************************/
  77
  78 /* FIXME: change this name, puh-leeze! */
  79 static void UpdateCatched(void);
  80 static void DrawPiece(short sq);
  81 static void ShowScore(short score);
  82 void Curses_UpdateDisplay(short f, short t, short redraw, short isspec);
  83 void Curses_Die(int sig);
  84 void Curses_ShowSidetoMove(void);
  85
  86 /****************************************
  87  * Trivial output functions.
  88  ****************************************/
  89
  90 static void
  91 ClearEoln(void)
  92 {
  93     clrtoeol();
  94     refresh();
  95 }
  96
  97
  98 void
  99 Curses_ClearScreen(void)
 100 {
 101     clear();
 102     refresh();
 103 }
 104
 105
 106 static void
 107 gotoXY(short x, short y)
 108 {
 109     move(y - 1, x - 1);
 110 }
 111
 112
 113 void
 114 Curses_ShowCurrentMove(short pnt, short f, short t)
 115 {
 116     algbr(f, t, false);
 117     gotoXY(TAB, 7);
 118     printw("(%2d) %5s ", pnt, mvstr[0]);
 119 }
 120
 121
 122 void
 123 Curses_ShowDepth(char ch)
 124 {
 125     gotoXY(TAB, 4);
 126     printw("Depth= %d%c ", Sdepth, ch);
 127     ClearEoln();
 128 }
 129
 130
 131 void
 132 Curses_ShowGameType(void)
 133 {
 134     if (flag.post)
 135     {
 136         gotoXY(TAB, 20);
 137         printw("%c vs. %c", GameType[black], GameType[white]);
 138     }
 139 }
 140
 141
 142 void
 143 ShowHeader(void)
 144 {
 145     gotoXY(TAB, 2);
 146     printw("GNU Shogi %s", PACKAGE_VERSION);
 147 }
 148
 149
 150 void
 151 Curses_ShowLine(unsigned short *bstline)
 152 {
 153 }
 154
 155
 156 void
 157 Curses_ShowMessage(char *s)
 158 {
 159     gotoXY(TAB, 6);
 160     printw("%s", s);
 161     ClearEoln();
 162 }
 163
 164
 165 void
 166 Curses_AlwaysShowMessage(const char *format, ...)
 167 {
 168     static char buffer[60];
 169     va_list ap;
 170     va_start(ap, format);
 171     vsnprintf(buffer, sizeof(buffer), format, ap);
 172     Curses_ShowMessage(buffer);
 173     va_end(ap);
 174 }
 175
 176
 177 void
 178 Curses_Printf(const char *format, ...)
 179 {
 180     static char buffer[60];
 181     va_list ap;
 182     va_start(ap, format);
 183     vsnprintf(buffer, sizeof(buffer), format, ap);
 184     printw("%s", buffer);
 185     va_end(ap);
 186 }
 187
 188
 189 void
 190 Curses_doRequestInputString(const char* fmt, char* buffer)
 191 {
 192     FLUSH_SCANW(fmt, buffer);
 193 }
 194
 195
 196 int
 197 Curses_GetString(char* sx)
 198 {
 199     fflush(stdout);
 200     return (getstr(sx) == ERR);
 201 }
 202
 203
 204 void
 205 Curses_ShowNodeCnt(long NodeCnt)
 206 {
 207     gotoXY(TAB, 22);
 208     /* printw("Nodes = %8ld, Nodes/Sec = %5ld", NodeCnt, (et > 100) ? NodeCnt / (et / 100) : 0); */
 209     printw("n = %ld n/s = %ld",
 210            NodeCnt, (et > 100) ? NodeCnt / (et / 100) : 0);
 211     ClearEoln();
 212 }
 213
 214
 215 void
 216 Curses_ShowPatternCount(short side, short n)
 217 {
 218     if (flag.post)
 219     {
 220         gotoXY(TAB + 10 + 3 * side, 20);          /* CHECKME */
 221
 222         if (n >= 0)
 223             printw("%3d", n);
 224         else
 225             printw("   ");
 226     }
 227 }
 228
 229
 230 static void
 231 ShowPlayers(void)
 232 {
 233     gotoXY(5, ((flag.reverse) ? (5 + 2*NO_ROWS) : 2));
 234     printw("%s", (computer == white) ? "Computer" : "Human   ");
 235     gotoXY(5, ((flag.reverse) ? 2 : (5 + 2*NO_ROWS)));
 236     printw("%s", (computer == black) ? "Computer" : "Human   ");
 237 }
 238
 239
 240 void
 241 Curses_ShowPrompt(void)
 242 {
 243     Curses_ShowSidetoMove();
 244     gotoXY(TAB, 17);
 245     printw("Your move is? ");
 246     ClearEoln();
 247 }
 248
 249
 250 void
 251 Curses_ShowResponseTime(void)
 252 {
 253     if (flag.post)
 254     {
 255         short TCC = TCcount;
 256         gotoXY(TAB, 21);
 257         printw("%ld, %d, %ld, %ld, %ld, %d",
 258                ResponseTime, TCC, TCleft, ExtraTime, et, flag.timeout);
 259         ClearEoln();
 260     }
 261 }
 262
 263
 264 void
 265 Curses_ShowResults(short score, unsigned short *bstline, char ch)
 266 {
 267     unsigned char d, ply;
 268
 269     if (flag.post)
 270     {
 271         Curses_ShowDepth(ch);
 272         ShowScore(score);
 273         d = 7;
 274
 275         for (ply = 1; bstline[ply] > 0; ply++)
 276         {
 277             if (ply % 2 == 1)
 278             {
 279                 gotoXY(TAB, ++d);
 280                 ClearEoln();
 281             }
 282
 283             algbr((short) bstline[ply] >> 8,
 284                   (short) bstline[ply] & 0xFF, false);
 285             printw("%5s ", mvstr[0]);
 286         }
 287
 288         ClearEoln();
 289
 290         while (d < 13)
 291         {
 292             gotoXY(TAB, ++d);
 293             ClearEoln();
 294         }
 295     }
 296 }
 297
 298
 299 static void
 300 ShowScore(short score)
 301 {
 302     gotoXY(TAB, 5);
 303     printw("Score= %d", score);
 304     ClearEoln();
 305 }
 306
 307
 308 void
 309 Curses_ShowSidetoMove(void)
 310 {
 311     gotoXY(TAB, 14);
 312     printw("%2d:   %s", 1 + GameCnt / 2, ColorStr[player]);
 313     ClearEoln();
 314 }
 315
 316
 317 void
 318 Curses_ShowStage(void)
 319 {
 320     gotoXY(TAB, 19);
 321     printw("Stage= %2d%c B= %2d W= %2d",
 322            stage, flag.tsume?'T':' ', balance[black], balance[white]);
 323     ClearEoln();
 324 }
 325
 326 /****************************************
 327  * End of trivial output routines.
 328  ****************************************/
 329
 330 void
 331 Curses_Initialize(void)
 332 {
 333     signal(SIGINT, Curses_Die);
 334     signal(SIGQUIT, Curses_Die);
 335     initscr();
 336     crmode();
 337 }
 338
 339
 340 void
 341 Curses_ExitShogi(void)
 342 {
 343     if (!nolist)
 344         ListGame();
 345
 346     gotoXY(1, 24);
 347
 348     refresh();
 349     nocrmode();
 350     endwin();
 351
 352     exit(0);
 353 }
 354
 355
 356 void
 357 Curses_Die(int sig)
 358 {
 359     char s[80];
 360
 361     signal(SIGINT, SIG_IGN);
 362     signal(SIGQUIT, SIG_IGN);
 363
 364     Curses_ShowMessage("Abort? ");
 365     FLUSH_SCANW("%s", s);
 366
 367     if (strcmp(s, "yes") == 0)
 368         Curses_ExitShogi();
 369
 370     signal(SIGINT, Curses_Die);
 371     signal(SIGQUIT, Curses_Die);
 372 }
 373
 374
 375 void
 376 Curses_TerminateSearch(int sig)
 377 {
 378     signal(SIGINT, SIG_IGN);
 379     signal(SIGQUIT, SIG_IGN);
 380
 381     if (!flag.timeout)
 382         flag.musttimeout = true;
 383
 384     Curses_ShowMessage("Terminate Search");
 385     flag.bothsides = false;
 386     signal(SIGINT, Curses_Die);
 387     signal(SIGQUIT, Curses_Die);
 388 }
 389
 390
 391 void
 392 Curses_help(void)
 393 {
 394     Curses_ClearScreen();
 395     printw("GNU Shogi %s command summary\n", PACKAGE_VERSION);
 396     printw("-------------------------------"
 397            "---------------------------------\n");
 398     printw("7g7f      move from 7g to 7f      quit      Exit Shogi\n");
 399     printw("S6h       move silver to 6h       beep      turn %s\n", (flag.beep) ? "OFF" : "ON");
 400     printw("2d2c+     move to 2c and promote  material  turn %s\n", (flag.material) ? "OFF" : "ON");
 401     printw("P*5e      drop pawn to 5e         easy      turn %s\n", (flag.easy) ? "OFF" : "ON");
 402     printw("tsume     toggle tsume mode       hash      turn %s\n", (flag.hash) ? "OFF" : "ON");
 403     printw("bd        redraw board            reverse   board display\n");
 404     printw("list      game to shogi.lst       book      turn %s used %d of %d\n", (Book) ? "OFF" : "ON", bookcount, BOOKSIZE);
 405     printw("undo      undo last ply           remove    take back a move\n");
 406     printw("edit      edit board              force     toggle manual move mode\n");
 407     printw("switch    sides with computer     both      computer match\n");
 408     printw("black     computer plays black    white     computer plays white\n");
 409     printw("depth     set search depth        clock     set time control\n");
 410     printw("post      principle variation     hint      suggest a move\n", (flag.post) ? "OFF" : "ON");
 411     printw("save      game to file            get       game from file\n");
 412     printw("random    randomize play          new       start new game\n");
 413     gotoXY(10, 20);
 414     printw("Computer: %s", ColorStr[computer]);
 415     gotoXY(10, 21);
 416     printw("Opponent: %s", ColorStr[opponent]);
 417     gotoXY(10, 22);
 418     printw("Level: %ld", MaxResponseTime/100);
 419     gotoXY(10, 23);
 420     printw("Easy mode: %s", (flag.easy) ? "ON" : "OFF");
 421     gotoXY(25, 23);
 422     printw("Tsume: %s", (flag.tsume) ? "ON" : "OFF");
 423     gotoXY(40, 20);
 424     printw("Depth: %d", MaxSearchDepth);
 425     gotoXY(40, 21);
 426     printw("Random: %s", (dither) ? "ON" : "OFF");
 427     gotoXY(40, 22);
 428     printw("Transposition table: %s", (flag.hash) ? "ON" : "OFF");
 429     gotoXY(40, 23);
 430     printw("Hit <RET> to return: ");
 431     gotoXY(10, 24);
 432     printw("Time Control %s %d moves %d sec %d add %d depth\n", (TCflag) ? "ON" : "OFF",
 433            TimeControl.moves[black],
 434            TimeControl.clock[black] / 100,
 435            OperatorTime, MaxSearchDepth);
 436
 437     refresh();
 438
 439 #ifdef BOGUS
 440     fflush(stdin); /* what is this supposed to do?? */
 441 #endif /* BOGUS */
 442
 443     getchar();
 444     Curses_ClearScreen();
 445     Curses_UpdateDisplay(0, 0, 1, 0);
 446 }
 447
 448
 449 static const short x0[2] = { 54, 2 };
 450 static const short y0[2] = { 20, 4 };
 451
 452
 453 /*
 454  * Set up a board position. Pieces are entered by typing the piece followed
 455  * by the location. For example, N3f will place a knight on square 3f.
 456  * P* will put a pawn to the captured pieces.
 457  */
 458
 459 void
 460 Curses_EditBoard(void)
 461 {
 462     short a, c, sq, i;
 463     short r = 0;
 464     char s[80];
 465
 466     flag.regularstart = true;
 467     Book = BOOKFAIL;
 468     Curses_ClearScreen();
 469     Curses_UpdateDisplay(0, 0, 1, 0);
 470     gotoXY(TAB, 3);
 471     printw(".   Exit to main\n");
 472     gotoXY(TAB, 4);
 473     printw("#   Clear board\n");
 474     gotoXY(TAB, 5);
 475     printw("c   Change sides\n");
 476     gotoXY(TAB, 7);
 477     printw("Enter piece & location: ");
 478     a = black;
 479
 480     do
 481     {
 482         gotoXY(TAB, 6);
 483         printw("Editing: %s", ColorStr[a]);
 484         gotoXY(TAB + 24, 7);
 485         ClearEoln();
 486         FLUSH_SCANW("%s", s);
 487
 488         if (s[0] == '#')
 489         {
 490             for (sq = 0; sq < NO_SQUARES; sq++)
 491             {
 492                 board[sq] = no_piece;
 493                 color[sq] = neutral;
 494                 DrawPiece(sq);
 495             }
 496
 497             ClearCaptured();
 498             UpdateCatched();
 499         }
 500
 501         if (s[0] == 'c')
 502             a = otherside[a];
 503
 504         if (s[1] == '*')
 505         {
 506             for (i = NO_PIECES; i > no_piece; i--)
 507             {
 508                 if ((s[0] == pxx[i]) || (s[0] == qxx[i]))
 509                     break;
 510             }
 511
 512             Captured[a][unpromoted[i]]++;
 513             UpdateCatched();
 514             c = -1;
 515         }
 516         else
 517         {
 518             c = COL_NAME(s[1]);
 519             r = ROW_NAME(s[2]);
 520         }
 521
 522         if ((c >= 0) && (c < NO_COLS) && (r >= 0) && (r < NO_ROWS))
 523         {
 524             sq = locn(r, c);
 525
 526             for (i = NO_PIECES; i > no_piece; i--)
 527             {
 528                 if ((s[0] == pxx[i]) || (s[0] == qxx[i]))
 529                     break;
 530             }
 531
 532             if (s[3] == '+')
 533                 i = promoted[i];
 534             else
 535                 i = unpromoted[i];
 536
 537             board[sq] = i;
 538             color[sq] = ((board[sq] == no_piece) ? neutral : a);
 539             DrawPiece(sq);
 540         }
 541     }
 542     while (s[0] != '.');
 543
 544     for (sq = 0; sq < NO_SQUARES; sq++)
 545         Mvboard[sq] = ((board[sq] != Stboard[sq]) ? 10 : 0);
 546
 547     GameCnt = 0;
 548     Game50 = 1;
 549     ZeroRPT();
 550     Sdepth = 0;
 551     InitializeStats();
 552     Curses_ClearScreen();
 553     Curses_UpdateDisplay(0, 0, 1, 0);
 554 }
 555
 556
 557 static void
 558 UpdateCatched()
 559 {
 560     short side;
 561
 562     for (side = black; side <= white; side++)
 563     {
 564         short x, y, piece, cside, k;
 565
 566         cside = flag.reverse ? (side ^ 1) : side;
 567         x = x0[cside];
 568         y = y0[cside];
 569         k = 0;
 570
 571         for (piece = pawn; piece <= king; piece++)
 572         {
 573             short n;
 574
 575             if ((n = Captured[side][piece]))
 576             {
 577                 gotoXY(x, y);
 578                 printw("%i%c", n, pxx[piece]);
 579
 580                 if (cside == black)
 581                     y--;
 582                 else
 583                     y++;
 584             }
 585             else
 586             {
 587                 k++;
 588             }
 589         }
 590
 591         while (k)
 592         {
 593             k--;
 594             gotoXY(x, y);
 595             printw("  ");
 596
 597             if (cside == black)
 598                 y--;
 599             else
 600                 y++;
 601         }
 602     }
 603
 604     refresh();
 605 }
 606
 607
 608 void
 609 Curses_SearchStartStuff(short side)
 610 {
 611     short i;
 612
 613     signal(SIGINT, Curses_TerminateSearch);
 614     signal(SIGQUIT, Curses_TerminateSearch);
 615
 616     for (i = 4; i < 14; i++)                      /* CHECKME */
 617     {
 618         gotoXY(TAB, i);
 619         ClearEoln();
 620     }
 621 }
 622
 623
 624 void
 625 Curses_OutputMove(void)
 626 {
 627
 628     Curses_UpdateDisplay(root->f, root->t, 0, (short) root->flags);
 629     gotoXY(TAB, 16);
 630
 631     if (flag.illegal)
 632     {
 633         printw("Illegal position.");
 634         return;
 635     }
 636
 637     printw("My move is: %5s", mvstr[0]);
 638
 639     if (flag.beep)
 640         putchar(7);
 641
 642     ClearEoln();
 643
 644     gotoXY(TAB, 18);
 645
 646     if (root->flags & draw)
 647         printw("Drawn game!");
 648     else if (root->score == -(SCORE_LIMIT + 999))
 649         printw("Opponent mates!");
 650     else if (root->score == SCORE_LIMIT + 998)
 651         printw("Computer mates!");
 652 #ifdef VERYBUGGY
 653     else if (root->score < -SCORE_LIMIT)
 654         printw("Opp: mate in %d!", SCORE_LIMIT + 999 + root->score - 1);
 655     else if (root->score > SCORE_LIMIT)
 656         printw("Comp: mate in %d!", SCORE_LIMIT + 998 - root->score - 1);
 657 #endif /* VERYBUGGY */
 658
 659     ClearEoln();
 660
 661     if (flag.post)
 662     {
 663         short h, l, t;
 664
 665         h = TREE;
 666         l = 0;
 667         t = TREE >> 1;
 668
 669         while (l != t)
 670         {
 671             if (Tree[t].f || Tree[t].t)
 672                 l = t;
 673             else
 674                 h = t;
 675
 676             t = (l + h) >> 1;
 677         }
 678
 679         Curses_ShowNodeCnt(NodeCnt);
 680         gotoXY(TAB, 23);
 681         printw("Max Tree = %5d", t);
 682         ClearEoln();
 683     }
 684
 685     Curses_ShowSidetoMove();
 686 }
 687
 688
 689 void
 690 Curses_UpdateClocks(void)
 691 {
 692     short m, s;
 693     long dt;
 694
 695     if (TCflag)
 696     {
 697         m = (short) ((dt = (TimeControl.clock[player] - et)) / 6000);
 698         s = (short) ((dt - 6000 * (long) m) / 100);
 699     }
 700     else
 701     {
 702         m = (short) ((dt = et) / 6000);
 703         s = (short) (et - 6000 * (long) m) / 100;
 704     }
 705
 706     if (m < 0)
 707         m = 0;
 708
 709     if (s < 0)
 710         s = 0;
 711
 712     if (player == black)
 713         gotoXY(20, (flag.reverse) ? 2 : 23);
 714     else
 715         gotoXY(20, (flag.reverse) ? 23 : 2);
 716
 717     /* printw("%d:%02d %ld  ", m, s, dt); */
 718     printw("%d:%02d  ", m, s);
 719
 720     if (flag.post)
 721         Curses_ShowNodeCnt(NodeCnt);
 722
 723     refresh();
 724 }
 725
 726
 727 static void
 728 DrawPiece(short sq)
 729 {
 730     char y;
 731     char piece, l, r, p;
 732
 733     if (color[sq] == neutral)
 734     {
 735         l = r = ' ';
 736     }
 737     else if (flag.reverse ^ (color[sq] == black))
 738     {
 739         l = '/';
 740         r = '\\';
 741     }
 742     else
 743     {
 744         l = '\\', r = '/';
 745     }
 746
 747     piece = board[sq];
 748
 749     if (is_promoted[(int)piece])
 750     {
 751         p = '+';
 752         y = pxx[unpromoted[(int)piece]];
 753     }
 754     else
 755     {
 756         p = ' ';
 757         y = pxx[(int)piece];
 758     }
 759
 760     gotoXY(8 + 5 * VIR_C(sq), 4 + 2 * ((NO_ROWS - 1) - VIR_R(sq)));
 761     printw("%c%c%c%c", l, p, y, r);
 762 }
 763
 764
 765 /*
 766  * Curses_ShowPostnValue(): must have called ExaminePosition() first
 767  */
 768 void
 769 Curses_ShowPostnValue(short sq)
 770 {
 771     gotoXY(4 + 5 * VIR_C(sq), 5 + 2 * (7 - VIR_R(sq))); /* CHECKME */
 772     (void) ScorePosition(color[sq]);
 773
 774     if (color[sq] != neutral)
 775 #if defined SAVE_SVALUE
 776     {
 777         printw("??? ");
 778     }
 779 #else
 780     {
 781         printw("%3d ", svalue[sq]);
 782     }
 783 #endif
 784     else
 785     {
 786         printw("   ");
 787     }
 788 }
 789
 790
 791 void
 792 Curses_ShowPostnValues(void)
 793 {
 794     short sq, score;
 795
 796     ExaminePosition(opponent);
 797
 798     for (sq = 0; sq < NO_SQUARES; sq++)
 799         Curses_ShowPostnValue(sq);
 800
 801     score = ScorePosition(opponent);
 802     gotoXY(TAB, 5);
 803     printw("S%d m%d ps%d gt%c m%d ps%d gt%c", score,
 804            mtl[computer], pscore[computer], GameType[computer],
 805            mtl[opponent], pscore[opponent], GameType[opponent]);
 806
 807     ClearEoln();
 808 }
 809
 810
 811 void
 812 Curses_UpdateDisplay(short f, short t, short redraw, short isspec)
 813 {
 814     short i, sq, z;
 815     int j;
 816
 817     if (redraw)
 818     {
 819         ShowHeader();
 820         ShowPlayers();
 821
 822         i = 2;
 823         gotoXY(3, ++i);
 824
 825         printw("    +");
 826         for (j=0; j<NO_COLS; j++)
 827             printw("----+");
 828
 829         while (i <= 1 + 2*NO_ROWS)
 830         {
 831             gotoXY(1, ++i);
 832
 833             if (flag.reverse)
 834                 z = (i / 2) - 1;
 835             else
 836                 z = NO_ROWS + 2 - ((i + 1) / 2);
 837
 838             printw("    %c |", ROW_NAME(z+1));
 839             for (j=0; j<NO_COLS; j++)
 840                 printw("    |");
 841
 842             gotoXY(3, ++i);
 843
 844             if (i < 2 + 2*NO_ROWS)
 845             {
 846                 printw("    +");
 847                 for (j=0; j<NO_COLS; j++)
 848                     printw("----+");
 849             }
 850         }
 851
 852         printw("    +");
 853         for (j=0; j<NO_COLS; j++)
 854             printw("----+");
 855
 856         gotoXY(3, 4 + 2*NO_ROWS);
 857         printw("    ");
 858
 859 #ifndef MINISHOGI
 860         if (flag.reverse)
 861             printw("  1    2    3    4    5    6    7    8    9");
 862         else
 863             printw("  9    8    7    6    5    4    3    2    1");
 864 #else
 865         if (flag.reverse)
 866             printw("  1    2    3    4    5");
 867         else
 868             printw("  1    2    3    4    5");
 869 #endif
 870
 871         for (sq = 0; sq < NO_SQUARES; sq++)
 872             DrawPiece(sq);
 873     }
 874     else /* not redraw */
 875     {
 876         if (f < NO_SQUARES)
 877             DrawPiece(f);
 878
 879         DrawPiece(t & 0x7f);
 880     }
 881
 882     if ((isspec & capture) || (isspec & dropmask) || redraw)
 883     {
 884         short side;
 885
 886         for (side = black; side <= white; side++)
 887         {
 888             short x, y, piece, cside, k;
 889             cside = flag.reverse ? (side ^ 1) : side;
 890             x = x0[cside];
 891             y = y0[cside];
 892             k = 0;
 893
 894             for (piece = pawn; piece <= king; piece++)
 895             {
 896                 short n;
 897
 898                 if ((n = Captured[side][piece]))
 899                 {
 900                     gotoXY(x, y);
 901                     printw("%i%c", n, pxx[piece]);
 902
 903                     if (cside == black) y--; else y++;
 904                 }
 905                 else
 906                 {
 907                     k++;
 908                 }
 909             }
 910
 911             while (k)
 912             {
 913                 k--;
 914                 gotoXY(x, y);
 915                 printw("  ");
 916
 917                 if (cside == black)
 918                     y--;
 919                 else
 920                     y++;
 921             }
 922         }
 923     }
 924
 925     refresh();
 926 }
 927
 928
 929 void
 930 Curses_ChangeAlphaWindow(void)
 931 {
 932     Curses_ShowMessage("WAwindow = ");
 933     FLUSH_SCANW("%hd", &WAwindow);
 934     Curses_ShowMessage("BAwindow = ");
 935     FLUSH_SCANW("%hd", &BAwindow);
 936 }
 937
 938
 939 void
 940 Curses_ChangeBetaWindow(void)
 941 {
 942     Curses_ShowMessage("WBwindow = ");
 943     FLUSH_SCANW("%hd", &WBwindow);
 944     Curses_ShowMessage("BBwindow = ");
 945     FLUSH_SCANW("%hd", &BBwindow);
 946 }
 947
 948
 949 void
 950 Curses_GiveHint(void)
 951 {
 952     char s[40];
 953
 954     if (hint)
 955     {
 956         algbr((short) (hint >> 8), (short) (hint & 0xFF), false);
 957         strcpy(s, "try ");
 958         strcat(s, mvstr[0]);
 959         Curses_ShowMessage(s);
 960     }
 961     else
 962     {
 963         Curses_ShowMessage("I have no idea.\n");
 964     }
 965 }
 966
 967
 968 void
 969 Curses_ChangeSearchDepth(char* sx)
 970 {
 971     Curses_ShowMessage("depth = ");
 972     FLUSH_SCANW("%hd", &MaxSearchDepth);
 973     TCflag = !(MaxSearchDepth > 0);
 974 }
 975
 976
 977 void
 978 Curses_ChangeHashDepth(void)
 979 {
 980     Curses_ShowMessage("hashdepth = ");
 981     FLUSH_SCANW("%hd", &HashDepth);
 982     Curses_ShowMessage("MoveLimit = ");
 983     FLUSH_SCANW("%hd", &HashMoveLimit);
 984 }
 985
 986
 987 void
 988 Curses_SetContempt(void)
 989 {
 990     Curses_ShowMessage("contempt = ");
 991     FLUSH_SCANW("%hd", &contempt);
 992 }
 993
 994
 995 void
 996 Curses_ChangeXwindow(void)
 997 {
 998     Curses_ShowMessage("xwndw= ");
 999     FLUSH_SCANW("%hd", &xwndw);
1000 }
1001
1002
1003 void
1004 Curses_SelectLevel(char *sx)
1005 {
1006     int item;
1007
1008     Curses_ClearScreen();
1009     gotoXY(32, 2);
1010     printw("GNU Shogi %s", PACKAGE_VERSION);
1011     gotoXY(20, 4);
1012     printw(" 1.   40 moves in   5 minutes");
1013     gotoXY(20, 5);
1014     printw(" 2.   40 moves in  15 minutes");
1015     gotoXY(20, 6);
1016     printw(" 3.   40 moves in  30 minutes");
1017     gotoXY(20, 7);
1018     printw(" 4.  all moves in  15 minutes");
1019     gotoXY(20, 8);
1020     printw(" 5.  all moves in  30 minutes");
1021     gotoXY(20, 9);
1022     printw(" 6.  all moves in  15 minutes, 30 seconds fischer clock");
1023     gotoXY(20, 10);
1024     printw(" 7.  all moves in  30 minutes, 30 seconds fischer clock");
1025     gotoXY(20, 11);
1026     printw(" 8.    1 move  in   1 minute");
1027     gotoXY(20, 12);
1028     printw(" 9.    1 move  in  15 minutes");
1029     gotoXY(20, 13);
1030     printw("10.    1 move  in  30 minutes");
1031
1032     OperatorTime = 0;
1033     TCmoves = 40;
1034     TCminutes = 5;
1035     TCseconds = 0;
1036
1037     gotoXY(20, 17);
1038     printw("Enter Level: ");
1039     refresh();
1040     FLUSH_SCANW("%d", &item);
1041
1042     switch(item)
1043     {
1044     case 1:
1045         TCmoves = 40;
1046         TCminutes = 5;
1047         break;
1048
1049     case 2:
1050         TCmoves = 40;
1051         TCminutes = 15;
1052         break;
1053
1054     case 3:
1055         TCmoves = 40;
1056         TCminutes = 30;
1057         break;
1058
1059     case 4:
1060         TCmoves = 80;
1061         TCminutes = 15;
1062         flag.gamein = true;
1063         break;
1064
1065     case 5:
1066         TCmoves = 80;
1067         TCminutes = 30;
1068         flag.gamein = true;
1069         break;
1070
1071     case 6:
1072         TCmoves = 80;
1073         TCminutes = 15;
1074         TCadd = 3000;
1075         flag.gamein = true;
1076         break;
1077
1078     case 7:
1079         TCmoves = 80;
1080         TCminutes = 30;
1081         TCadd = 3000;
1082         break;
1083
1084     case 8:
1085         TCmoves = 1;
1086         TCminutes = 1;
1087         flag.onemove = true;
1088         break;
1089
1090     case 9:
1091         TCmoves = 1;
1092         TCminutes = 15;
1093         flag.onemove = true;
1094         break;
1095
1096     case 10:
1097         TCmoves = 1;
1098         TCminutes = 30;
1099         flag.onemove = true;
1100         break;
1101     }
1102
1103     TCflag = (TCmoves > 0);
1104
1105     TimeControl.clock[black] = TimeControl.clock[white] = 0;
1106
1107     SetTimeControl();
1108     Curses_ClearScreen();
1109     Curses_UpdateDisplay(0, 0, 1, 0);
1110 }
1111
1112
1113 void
1114 Curses_DoDebug(void)
1115 {
1116     short c, p, sq, tp, tc, tsq, score;
1117     char s[40];
1118
1119     ExaminePosition(opponent);
1120     Curses_ShowMessage("Enter piece: ");
1121     FLUSH_SCANW("%s", s);
1122     c = neutral;
1123
1124     if ((s[0] == 'b') || (s[0] == 'B'))
1125         c = black;
1126
1127     if ((s[0] == 'w') || (s[0] == 'W'))
1128         c = white;
1129
1130     for (p = king; p > no_piece; p--)
1131     {
1132         if ((s[1] == pxx[p]) || (s[1] == qxx[p]))
1133             break;
1134     }
1135
1136     for (sq = 0; sq < NO_SQUARES; sq++)
1137     {
1138         tp = board[sq];
1139         tc = color[sq];
1140         board[sq] = p;
1141         color[sq] = c;
1142         tsq = PieceList[c][1];
1143         PieceList[c][1] = sq;
1144         Curses_ShowPostnValue(sq);
1145         PieceList[c][1] = tsq;
1146         board[sq] = tp;
1147         color[sq] = tc;
1148     }
1149
1150     score = ScorePosition(opponent);
1151     gotoXY(TAB, 5);
1152     printw("S%d m%d ps%d gt%c m%d ps%d gt%c", score,
1153            mtl[computer], pscore[computer], GameType[computer],
1154            mtl[opponent], pscore[opponent], GameType[opponent]);
1155
1156     ClearEoln();
1157 }
1158
1159
1160 void
1161 Curses_DoTable(short table[NO_SQUARES])
1162 {
1163     short  sq;
1164     ExaminePosition(opponent);
1165
1166     for (sq = 0; sq < NO_SQUARES; sq++)
1167     {
1168         gotoXY(4 + 5 * VIR_C(sq), 5 + 2 * (7 - VIR_R(sq)));
1169         printw("%3d ", table[sq]);
1170     }
1171 }
1172
1173
1174 void
1175 Curses_PollForInput(void)
1176 {
1177     int  i;
1178     int  nchar;
1179
1180     if ((i = ioctl((int) 0, FIONREAD, &nchar)))
1181     {
1182         perror("FIONREAD");
1183         fprintf(stderr,
1184                 "You probably have a non-ANSI <ioctl.h>; "
1185                 "see README. %d %d %x\n",
1186                 i, errno, FIONREAD);
1187         exit(1);
1188     }
1189
1190     if (nchar)
1191     {
1192         if (!flag.timeout)
1193             flag.back = true;
1194
1195         flag.bothsides = false;
1196     }
1197 }
1198
1199
1200 void
1201 Curses_SetupBoard(void)
1202 {
1203     Curses_ShowMessage("'setup' command is not supported in Cursesmode");
1204 }
1205
1206
1207 struct display curses_display =
1208 {
1209     .ChangeAlphaWindow    = Curses_ChangeAlphaWindow,
1210     .ChangeBetaWindow     = Curses_ChangeBetaWindow,
1211     .ChangeHashDepth      = Curses_ChangeHashDepth,
1212     .ChangeSearchDepth    = Curses_ChangeSearchDepth,
1213     .ChangeXwindow        = Curses_ChangeXwindow,
1214     .ClearScreen          = Curses_ClearScreen,
1215     .DoDebug              = Curses_DoDebug,
1216     .DoTable              = Curses_DoTable,
1217     .EditBoard            = Curses_EditBoard,
1218     .ExitShogi            = Curses_ExitShogi,
1219     .GiveHint             = Curses_GiveHint,
1220     .Initialize           = Curses_Initialize,
1221     .ShowNodeCnt          = Curses_ShowNodeCnt,
1222     .OutputMove           = Curses_OutputMove,
1223     .PollForInput         = Curses_PollForInput,
1224     .SetContempt          = Curses_SetContempt,
1225     .SearchStartStuff     = Curses_SearchStartStuff,
1226     .SelectLevel          = Curses_SelectLevel,
1227     .ShowCurrentMove      = Curses_ShowCurrentMove,
1228     .ShowDepth            = Curses_ShowDepth,
1229     .ShowGameType         = Curses_ShowGameType,
1230     .ShowLine             = Curses_ShowLine,
1231     .ShowMessage          = Curses_ShowMessage,
1232     .AlwaysShowMessage    = Curses_AlwaysShowMessage,
1233     .Printf               = Curses_Printf,
1234     .doRequestInputString = Curses_doRequestInputString,
1235     .GetString            = Curses_GetString,
1236     .SetupBoard           = Curses_SetupBoard,
1237     .ShowPatternCount     = Curses_ShowPatternCount,
1238     .ShowPostnValue       = Curses_ShowPostnValue,
1239     .ShowPostnValues      = Curses_ShowPostnValues,
1240     .ShowPrompt           = Curses_ShowPrompt,
1241     .ShowResponseTime     = Curses_ShowResponseTime,
1242     .ShowResults          = Curses_ShowResults,
1243     .ShowSidetoMove       = Curses_ShowSidetoMove,
1244     .ShowStage            = Curses_ShowStage,
1245     .TerminateSearch      = Curses_TerminateSearch,
1246     .UpdateClocks         = Curses_UpdateClocks,
1247     .UpdateDisplay        = Curses_UpdateDisplay,
1248     .help                 = Curses_help,
1249 };