gnushogi/cursesdsp.c

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